diff options
117 files changed, 913 insertions, 795 deletions
diff --git a/.gitignore b/.gitignore index cc892f2a3d4..7ef656055ec 100644 --- a/.gitignore +++ b/.gitignore @@ -39,6 +39,7 @@ *.diff *.rej *.swp +*.swo *.tmp *.pyc *.elc diff --git a/.swo b/.swo new file mode 100644 index 00000000000..89f7479da33 --- /dev/null +++ b/.swo Binary files differdiff --git a/doc/tutorial-borrowed-ptr.md b/doc/tutorial-borrowed-ptr.md index 039721fb12e..90b8e1051eb 100644 --- a/doc/tutorial-borrowed-ptr.md +++ b/doc/tutorial-borrowed-ptr.md @@ -42,14 +42,14 @@ point, but allocated in a different place: ~~~ # struct Point {x: float, y: float} let on_the_stack : Point = Point {x: 3.0, y: 4.0}; -let shared_box : @Point = @Point {x: 5.0, y: 1.0}; -let unique_box : ~Point = ~Point {x: 7.0, y: 9.0}; +let managed_box : @Point = @Point {x: 5.0, y: 1.0}; +let owned_box : ~Point = ~Point {x: 7.0, y: 9.0}; ~~~ Suppose we wanted to write a procedure that computed the distance between any two points, no matter where they were stored. For example, we might like to -compute the distance between `on_the_stack` and `shared_box`, or between -`shared_box` and `unique_box`. One option is to define a function that takes +compute the distance between `on_the_stack` and `managed_box`, or between +`managed_box` and `owned_box`. One option is to define a function that takes two arguments of type `Point`—that is, it takes the points by value. But if we define it this way, calling the function will cause the points to be copied. For points, this is probably not so bad, but often copies are @@ -73,11 +73,11 @@ Now we can call `compute_distance()` in various ways: ~~~ # struct Point {x: float, y: float} # let on_the_stack : Point = Point{x: 3.0, y: 4.0}; -# let shared_box : @Point = @Point{x: 5.0, y: 1.0}; -# let unique_box : ~Point = ~Point{x: 7.0, y: 9.0}; +# let managed_box : @Point = @Point{x: 5.0, y: 1.0}; +# let owned_box : ~Point = ~Point{x: 7.0, y: 9.0}; # fn compute_distance(p1: &Point, p2: &Point) -> float { 0f } -compute_distance(&on_the_stack, shared_box); -compute_distance(shared_box, unique_box); +compute_distance(&on_the_stack, managed_box); +compute_distance(managed_box, owned_box); ~~~ Here, the `&` operator takes the address of the variable @@ -87,11 +87,11 @@ value. We also call this _borrowing_ the local variable `on_the_stack`, because we have created an alias: that is, another name for the same data. -In contrast, we can pass the boxes `shared_box` and `unique_box` to +In contrast, we can pass the boxes `managed_box` and `owned_box` to `compute_distance` directly. The compiler automatically converts a box like `@Point` or `~Point` to a borrowed pointer like `&Point`. This is another form -of borrowing: in this case, the caller lends the contents of the shared or -unique box to the callee. +of borrowing: in this case, the caller lends the contents of the managed or +owned box to the callee. Whenever a caller lends data to a callee, there are some limitations on what the caller can do with the original. For example, if the contents of a @@ -155,7 +155,7 @@ let rect_stack = &Rectangle {origin: Point {x: 1f, y: 2f}, size: Size {w: 3f, h: 4f}}; let rect_managed = @Rectangle {origin: Point {x: 3f, y: 4f}, size: Size {w: 3f, h: 4f}}; -let rect_unique = ~Rectangle {origin: Point {x: 5f, y: 6f}, +let rect_owned = ~Rectangle {origin: Point {x: 5f, y: 6f}, size: Size {w: 3f, h: 4f}}; ~~~ @@ -168,7 +168,7 @@ operator. For example, I could write: # struct Rectangle {origin: Point, size: Size} # let rect_stack = &Rectangle {origin: Point {x: 1f, y: 2f}, size: Size {w: 3f, h: 4f}}; # let rect_managed = @Rectangle {origin: Point {x: 3f, y: 4f}, size: Size {w: 3f, h: 4f}}; -# let rect_unique = ~Rectangle {origin: Point {x: 5f, y: 6f}, size: Size {w: 3f, h: 4f}}; +# let rect_owned = ~Rectangle {origin: Point {x: 5f, y: 6f}, size: Size {w: 3f, h: 4f}}; # fn compute_distance(p1: &Point, p2: &Point) -> float { 0f } compute_distance(&rect_stack.origin, &rect_managed.origin); ~~~ @@ -179,7 +179,7 @@ as well as from the managed box, and then compute the distance between them. # Borrowing managed boxes and rooting We’ve seen a few examples so far of borrowing heap boxes, both managed -and unique. Up till this point, we’ve glossed over issues of +and owned. Up till this point, we’ve glossed over issues of safety. As stated in the introduction, at runtime a borrowed pointer is simply a pointer, nothing more. Therefore, avoiding C's problems with dangling pointers requires a compile-time safety check. @@ -258,18 +258,18 @@ fn example2() { Now if `x` is reassigned, the pointer `y` will still remain valid. This process is called *rooting*. -# Borrowing unique boxes +# Borrowing owned boxes The previous example demonstrated *rooting*, the process by which the compiler ensures that managed boxes remain live for the duration of a -borrow. Unfortunately, rooting does not work for borrows of unique -boxes, because it is not possible to have two references to a unique +borrow. Unfortunately, rooting does not work for borrows of owned +boxes, because it is not possible to have two references to a owned box. -For unique boxes, therefore, the compiler will only allow a borrow *if -the compiler can guarantee that the unique box will not be reassigned +For owned boxes, therefore, the compiler will only allow a borrow *if +the compiler can guarantee that the owned box will not be reassigned or moved for the lifetime of the pointer*. This does not necessarily -mean that the unique box is stored in immutable memory. For example, +mean that the owned box is stored in immutable memory. For example, the following function is legal: ~~~ @@ -294,7 +294,7 @@ and `x` is declared as mutable. However, the compiler can prove that and in fact is mutated later in the function. It may not be clear why we are so concerned about mutating a borrowed -variable. The reason is that the runtime system frees any unique box +variable. The reason is that the runtime system frees any owned box _as soon as its owning reference changes or goes out of scope_. Therefore, a program like this is illegal (and would be rejected by the compiler): @@ -342,7 +342,7 @@ which has been freed. In fact, the compiler can apply the same kind of reasoning to any memory that is _(uniquely) owned by the stack frame_. So we could -modify the previous example to introduce additional unique pointers +modify the previous example to introduce additional owned pointers and structs, and the compiler will still be able to detect possible mutations: @@ -366,7 +366,7 @@ invalidate the pointer `y`. # Borrowing and enums The previous example showed that the type system forbids any borrowing -of unique boxes found in aliasable, mutable memory. This restriction +of owned boxes found in aliasable, mutable memory. This restriction prevents pointers from pointing into freed memory. There is one other case where the compiler must be very careful to ensure that pointers remain valid: pointers into the interior of an `enum`. @@ -462,14 +462,14 @@ of a `float` as if it were a struct with two fields would be a memory safety violation. So, in fact, for every `ref` binding, the compiler will impose the -same rules as the ones we saw for borrowing the interior of a unique +same rules as the ones we saw for borrowing the interior of a owned box: it must be able to guarantee that the `enum` will not be overwritten for the duration of the borrow. In fact, the compiler would accept the example we gave earlier. The example is safe because the shape pointer has type `&Shape`, which means "borrowed pointer to immutable memory containing a `shape`". If, however, the type of that pointer were `&mut Shape`, then the ref binding would be ill-typed. -Just as with unique boxes, the compiler will permit `ref` bindings +Just as with owned boxes, the compiler will permit `ref` bindings into data owned by the stack frame even if the data are mutable, but otherwise it requires that the data reside in immutable memory. @@ -550,7 +550,7 @@ guarantees; in fact, it cannot guarantee that the pointer will remain valid at all once it returns, as the parameter `p` may or may not be live in the caller. Therefore, the compiler will report an error here. -In general, if you borrow a managed (or unique) box to create a +In general, if you borrow a managed (or owned) box to create a borrowed pointer, the pointer will only be valid within the function and cannot be returned. This is why the typical way to return borrowed pointers is to take borrowed pointers as input (the only other case in diff --git a/doc/tutorial.md b/doc/tutorial.md index 4a680d01303..7ee78d622f3 100644 --- a/doc/tutorial.md +++ b/doc/tutorial.md @@ -1779,7 +1779,7 @@ to a borrowed pointer. # fn draw_value(self) { ... } # } # let s = Circle(Point { x: 1f, y: 2f }, 3f); -// As with typical function arguments, managed and unique pointers +// As with typical function arguments, managed and owned pointers // are automatically converted to borrowed pointers (@s).draw_borrowed(); diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs index 73e1e3ee763..d58c2e596bd 100644 --- a/src/compiletest/runtest.rs +++ b/src/compiletest/runtest.rs @@ -264,7 +264,7 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) { fatal(~"gdb failed to execute"); } - let num_check_lines = vec::len(check_lines); + let num_check_lines = check_lines.len(); if num_check_lines > 0 { // check if each line in props.check_lines appears in the // output (in order) @@ -303,7 +303,7 @@ fn check_error_patterns(props: &TestProps, if str::contains(line, *next_err_pat) { debug!("found error pattern %s", *next_err_pat); next_err_idx += 1u; - if next_err_idx == vec::len(props.error_patterns) { + if next_err_idx == props.error_patterns.len() { debug!("found all error patterns"); done = true; break; @@ -315,8 +315,8 @@ fn check_error_patterns(props: &TestProps, let missing_patterns = vec::slice(props.error_patterns, next_err_idx, - vec::len(props.error_patterns)); - if vec::len(missing_patterns) == 1u { + props.error_patterns.len()); + if missing_patterns.len() == 1u { fatal_ProcRes(fmt!("error pattern '%s' not found!", missing_patterns[0]), ProcRes); } else { @@ -333,7 +333,7 @@ fn check_expected_errors(expected_errors: ~[errors::ExpectedError], // true if we found the error in question let mut found_flags = vec::from_elem( - vec::len(expected_errors), false); + expected_errors.len(), false); if ProcRes.status == 0 { fatal(~"process did not return an error status"); @@ -377,7 +377,7 @@ fn check_expected_errors(expected_errors: ~[errors::ExpectedError], } } - for uint::range(0u, vec::len(found_flags)) |i| { + for uint::range(0u, found_flags.len()) |i| { if !found_flags[i] { let ee = &expected_errors[i]; fatal_ProcRes(fmt!("expected %s on line %u not found: %s", diff --git a/src/libcore/either.rs b/src/libcore/either.rs index 618a484a515..8c16f5c6482 100644 --- a/src/libcore/either.rs +++ b/src/libcore/either.rs @@ -201,14 +201,14 @@ fn test_lefts() { fn test_lefts_none() { let input: ~[Either<int, int>] = ~[Right(10), Right(10)]; let result = lefts(input); - assert_eq!(vec::len(result), 0u); + assert_eq!(result.len(), 0u); } #[test] fn test_lefts_empty() { let input: ~[Either<int, int>] = ~[]; let result = lefts(input); - assert_eq!(vec::len(result), 0u); + assert_eq!(result.len(), 0u); } #[test] @@ -222,14 +222,14 @@ fn test_rights() { fn test_rights_none() { let input: ~[Either<int, int>] = ~[Left(10), Left(10)]; let result = rights(input); - assert_eq!(vec::len(result), 0u); + assert_eq!(result.len(), 0u); } #[test] fn test_rights_empty() { let input: ~[Either<int, int>] = ~[]; let result = rights(input); - assert_eq!(vec::len(result), 0u); + assert_eq!(result.len(), 0u); } #[test] @@ -247,22 +247,22 @@ fn test_partition() { fn test_partition_no_lefts() { let input: ~[Either<int, int>] = ~[Right(10), Right(11)]; let (lefts, rights) = partition(input); - assert_eq!(vec::len(lefts), 0u); - assert_eq!(vec::len(rights), 2u); + assert_eq!(lefts.len(), 0u); + assert_eq!(rights.len(), 2u); } #[test] fn test_partition_no_rights() { let input: ~[Either<int, int>] = ~[Left(10), Left(11)]; let (lefts, rights) = partition(input); - assert_eq!(vec::len(lefts), 2u); - assert_eq!(vec::len(rights), 0u); + assert_eq!(lefts.len(), 2u); + assert_eq!(rights.len(), 0u); } #[test] fn test_partition_empty() { let input: ~[Either<int, int>] = ~[]; let (lefts, rights) = partition(input); - assert_eq!(vec::len(lefts), 0u); - assert_eq!(vec::len(rights), 0u); + assert_eq!(lefts.len(), 0u); + assert_eq!(rights.len(), 0u); } diff --git a/src/libcore/io.rs b/src/libcore/io.rs index ab5db67ddb6..7b7d278380f 100644 --- a/src/libcore/io.rs +++ b/src/libcore/io.rs @@ -673,10 +673,10 @@ impl<T:Reader> ReaderUtil for T { fn read_char(&self) -> char { let c = self.read_chars(1); - if vec::len(c) == 0 { + if c.len() == 0 { return -1 as char; // FIXME will this stay valid? // #2004 } - assert!((vec::len(c) == 1)); + assert!(c.len() == 1); return c[0]; } @@ -1802,7 +1802,7 @@ mod tests { fn test_readchars_empty() { do io::with_str_reader(~"") |inp| { let res : ~[char] = inp.read_chars(128); - assert!((vec::len(res) == 0)); + assert!(res.len() == 0); } } @@ -1841,10 +1841,10 @@ mod tests { fn check_read_ln(len : uint, s: &str, ivals: &[int]) { do io::with_str_reader(s) |inp| { let res : ~[char] = inp.read_chars(len); - if (len <= vec::len(ivals)) { - assert!((vec::len(res) == len)); + if len <= ivals.len() { + assert!(res.len() == len); } - assert!(vec::slice(ivals, 0u, vec::len(res)) == + assert!(vec::slice(ivals, 0u, res.len()) == vec::map(res, |x| *x as int)); } } diff --git a/src/libcore/os.rs b/src/libcore/os.rs index 9129b33fff5..daad9cee0fc 100644 --- a/src/libcore/os.rs +++ b/src/libcore/os.rs @@ -410,7 +410,7 @@ pub fn self_exe_path() -> Option<Path> { KERN_PROC as c_int, KERN_PROC_PATHNAME as c_int, -1 as c_int]; let mut sz = sz; - sysctl(vec::raw::to_ptr(mib), vec::len(mib) as ::libc::c_uint, + sysctl(vec::raw::to_ptr(mib), mib.len() as ::libc::c_uint, buf as *mut c_void, &mut sz, ptr::null(), 0u as size_t) == (0 as c_int) } @@ -1490,7 +1490,7 @@ mod tests { #[ignore] fn test_env_getenv() { let e = env(); - assert!(vec::len(e) > 0u); + assert!(e.len() > 0u); for e.each |p| { let (n, v) = copy *p; debug!(copy n); @@ -1581,7 +1581,7 @@ mod tests { fn list_dir() { let dirs = os::list_dir(&Path(".")); // Just assuming that we've got some contents in the current directory - assert!((vec::len(dirs) > 0u)); + assert!(dirs.len() > 0u); for dirs.each |dir| { debug!(copy *dir); diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs index 9feb8676036..e116dc01943 100644 --- a/src/libcore/ptr.rs +++ b/src/libcore/ptr.rs @@ -441,7 +441,7 @@ pub mod ptr_tests { let arr_ptr = &arr[0]; let mut ctr = 0; let mut iteration_count = 0; - array_each_with_len(arr_ptr, vec::len(arr), + array_each_with_len(arr_ptr, arr.len(), |e| { let actual = str::raw::from_c_str(e); let expected = copy expected_arr[ctr]; diff --git a/src/libcore/rt/uvll.rs b/src/libcore/rt/uvll.rs index 4bff3bff7d3..0d298bde6b5 100644 --- a/src/libcore/rt/uvll.rs +++ b/src/libcore/rt/uvll.rs @@ -221,7 +221,7 @@ pub unsafe fn accept(server: *c_void, client: *c_void) -> c_int { pub unsafe fn write<T>(req: *uv_write_t, stream: *T, buf_in: &[uv_buf_t], cb: *u8) -> c_int { let buf_ptr = vec::raw::to_ptr(buf_in); - let buf_cnt = vec::len(buf_in) as i32; + let buf_cnt = buf_in.len() as i32; return rust_uv_write(req as *c_void, stream as *c_void, buf_ptr, buf_cnt, cb); } pub unsafe fn read_start(stream: *uv_stream_t, on_alloc: *u8, on_read: *u8) -> c_int { diff --git a/src/libcore/str.rs b/src/libcore/str.rs index ce9db796b67..ec7177e5211 100644 --- a/src/libcore/str.rs +++ b/src/libcore/str.rs @@ -2059,7 +2059,7 @@ pub fn is_utf8(v: &const [u8]) -> bool { /// Determines if a vector of `u16` contains valid UTF-16 pub fn is_utf16(v: &[u16]) -> bool { - let len = vec::len(v); + let len = v.len(); let mut i = 0u; while (i < len) { let u = v[i]; @@ -2103,7 +2103,7 @@ pub fn to_utf16(s: &str) -> ~[u16] { } pub fn utf16_chars(v: &[u16], f: &fn(char)) { - let len = vec::len(v); + let len = v.len(); let mut i = 0u; while (i < len && v[i] != 0u16) { let u = v[i]; @@ -2128,7 +2128,7 @@ pub fn utf16_chars(v: &[u16], f: &fn(char)) { pub fn from_utf16(v: &[u16]) -> ~str { let mut buf = ~""; - reserve(&mut buf, vec::len(v)); + reserve(&mut buf, v.len()); utf16_chars(v, |ch| push_char(&mut buf, ch)); buf } @@ -2398,7 +2398,7 @@ static tag_six_b: uint = 252u; * # Example * * ~~~ - * let i = str::as_bytes("Hello World") { |bytes| vec::len(bytes) }; + * let i = str::as_bytes("Hello World") { |bytes| bytes.len() }; * ~~~ */ #[inline] diff --git a/src/libcore/to_bytes.rs b/src/libcore/to_bytes.rs index 6cc621e3419..ad42881ffa0 100644 --- a/src/libcore/to_bytes.rs +++ b/src/libcore/to_bytes.rs @@ -458,6 +458,7 @@ pub fn iter_bytes_2<A:IterBytes,B:IterBytes>(a: &A, b: &B, b.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag}); } #[cfg(not(stage0))] +#[inline(always)] pub fn iter_bytes_2<A:IterBytes,B:IterBytes>(a: &A, b: &B, lsb0: bool, z: Cb) -> bool { a.iter_bytes(lsb0, z) && b.iter_bytes(lsb0, z) diff --git a/src/libfuzzer/ast_match.rs b/src/libfuzzer/ast_match.rs index 806a7aedd31..2502830250d 100644 --- a/src/libfuzzer/ast_match.rs +++ b/src/libfuzzer/ast_match.rs @@ -15,8 +15,8 @@ fn vec_equal<T>(v: ~[T], u: ~[T], element_equality_test: @fn(&&T, &&T) -> bool) -> bool { - let Lv = vec::len(v); - if Lv != vec::len(u) { return false; } + let Lv = v.len(); + if Lv != u.len() { return false; } let i = 0u; while i < Lv { if !element_equality_test(v[i], u[i]) { return false; } diff --git a/src/libfuzzer/cycles.rs b/src/libfuzzer/cycles.rs index c18d1f43b56..a6434d64cdc 100644 --- a/src/libfuzzer/cycles.rs +++ b/src/libfuzzer/cycles.rs @@ -19,7 +19,7 @@ fn under(r : rand::rng, n : uint) -> uint { // random choice from a vec fn choice<T:copy>(r : rand::rng, v : ~[const T]) -> T { - assert!(vec::len(v) != 0u); v[under(r, vec::len(v))] + assert!(v.len() != 0u); v[under(r, v.len())] } // k in n chance of being true diff --git a/src/libfuzzer/rand_util.rs b/src/libfuzzer/rand_util.rs index 2422c146e24..c239e8ab933 100644 --- a/src/libfuzzer/rand_util.rs +++ b/src/libfuzzer/rand_util.rs @@ -18,7 +18,7 @@ fn under(r : rand::rng, n : uint) -> uint { // random choice from a vec fn choice<T:copy>(r : rand::rng, v : ~[T]) -> T { - assert!(vec::len(v) != 0u); v[under(r, vec::len(v))] + assert!(v.len() != 0u); v[under(r, v.len())] } // 1 in n chance of being true @@ -26,7 +26,7 @@ fn unlikely(r : rand::rng, n : uint) -> bool { under(r, n) == 0u } // shuffle a vec in place fn shuffle<T>(r : rand::rng, &v : ~[T]) { - let i = vec::len(v); + let i = v.len(); while i >= 2u { // Loop invariant: elements with index >= i have been locked in place. i -= 1u; @@ -49,7 +49,7 @@ fn shuffled<T:copy>(r : rand::rng, v : ~[T]) -> ~[T] { // * weighted_vec is O(total weight) space type weighted<T> = { weight: uint, item: T }; fn weighted_choice<T:copy>(r : rand::rng, v : ~[weighted<T>]) -> T { - assert!(vec::len(v) != 0u); + assert!(v.len() != 0u); let total = 0u; for {weight: weight, item: _} in v { total += weight; diff --git a/src/librustc/back/rpath.rs b/src/librustc/back/rpath.rs index eebb20b19f5..37a025cd820 100644 --- a/src/librustc/back/rpath.rs +++ b/src/librustc/back/rpath.rs @@ -137,8 +137,8 @@ pub fn get_relative_to(abs1: &Path, abs2: &Path) -> Path { abs1.to_str(), abs2.to_str()); let split1: &[~str] = abs1.components; let split2: &[~str] = abs2.components; - let len1 = vec::len(split1); - let len2 = vec::len(split2); + let len1 = split1.len(); + let len2 = split2.len(); assert!(len1 > 0); assert!(len2 > 0); diff --git a/src/librustc/driver/driver.rs b/src/librustc/driver/driver.rs index b11aec5b841..0e37653e5c4 100644 --- a/src/librustc/driver/driver.rs +++ b/src/librustc/driver/driver.rs @@ -905,7 +905,6 @@ mod test { use driver::driver::{build_configuration, build_session}; use driver::driver::{build_session_options, optgroups, str_input}; - use core::vec; use std::getopts::groups::getopts; use std::getopts; use syntax::attr; @@ -942,6 +941,6 @@ mod test { let sess = build_session(sessopts, diagnostic::emit); let cfg = build_configuration(sess, @~"whatever", &str_input(~"")); let test_items = attr::find_meta_items_by_name(cfg, ~"test"); - assert!((vec::len(test_items) == 1u)); + assert!(test_items.len() == 1u); } } diff --git a/src/librustc/front/test.rs b/src/librustc/front/test.rs index f556baee918..be03ed99ad7 100644 --- a/src/librustc/front/test.rs +++ b/src/librustc/front/test.rs @@ -206,7 +206,7 @@ fn is_bench_fn(i: @ast::item) -> bool { fn has_test_signature(i: @ast::item) -> bool { match i.node { ast::item_fn(ref decl, _, _, ref generics, _) => { - let input_cnt = vec::len(decl.inputs); + let input_cnt = decl.inputs.len(); let no_output = match decl.output.node { ast::ty_nil => true, _ => false diff --git a/src/librustc/metadata/common.rs b/src/librustc/metadata/common.rs index d2b71447f47..9426cd6041d 100644 --- a/src/librustc/metadata/common.rs +++ b/src/librustc/metadata/common.rs @@ -100,7 +100,7 @@ pub static tag_mod_impl_trait: uint = 0x47u; different tags. */ pub static tag_item_impl_method: uint = 0x48u; -pub static tag_item_trait_method_self_ty: uint = 0x4b; +pub static tag_item_trait_method_explicit_self: uint = 0x4b; pub static tag_item_trait_method_self_ty_region: uint = 0x4c; diff --git a/src/librustc/metadata/csearch.rs b/src/librustc/metadata/csearch.rs index d8117a87480..e6b8432854d 100644 --- a/src/librustc/metadata/csearch.rs +++ b/src/librustc/metadata/csearch.rs @@ -22,7 +22,7 @@ use syntax::ast_map; use syntax::diagnostic::expect; pub struct ProvidedTraitMethodInfo { - ty: ty::method, + ty: ty::Method, def_id: ast::def_id } @@ -129,17 +129,18 @@ pub fn get_impls_for_mod(cstore: @mut cstore::CStore, def: ast::def_id, } pub fn get_method(tcx: ty::ctxt, - def: ast::def_id) -> ty::method + def: ast::def_id) -> ty::Method { let cdata = cstore::get_crate_data(tcx.cstore, def.crate); decoder::get_method(tcx.cstore.intr, cdata, def.node, tcx) } -pub fn get_method_name_and_self_ty(cstore: @mut cstore::CStore, - def: ast::def_id) -> (ast::ident, ast::self_ty_) +pub fn get_method_name_and_explicit_self(cstore: @mut cstore::CStore, + def: ast::def_id) + -> (ast::ident, ast::explicit_self_) { let cdata = cstore::get_crate_data(cstore, def.crate); - decoder::get_method_name_and_self_ty(cstore.intr, cdata, def.node) + decoder::get_method_name_and_explicit_self(cstore.intr, cdata, def.node) } pub fn get_trait_method_def_ids(cstore: @mut cstore::CStore, diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index c3dd9cdf23b..2592875cd57 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -653,7 +653,7 @@ pub fn get_enum_variants(intr: @ident_interner, cdata: cmd, id: ast::node_id, item, tcx, cdata); let name = item_name(intr, item); let arg_tys = match ty::get(ctor_ty).sty { - ty::ty_bare_fn(ref f) => f.sig.inputs.map(|a| a.ty), + ty::ty_bare_fn(ref f) => copy f.sig.inputs, _ => ~[], // Nullary enum variant. }; match variant_disr_val(item) { @@ -670,7 +670,7 @@ pub fn get_enum_variants(intr: @ident_interner, cdata: cmd, id: ast::node_id, return infos; } -fn get_self_ty(item: ebml::Doc) -> ast::self_ty_ { +fn get_explicit_self(item: ebml::Doc) -> ast::explicit_self_ { fn get_mutability(ch: u8) -> ast::mutability { match ch as char { 'i' => { ast::m_imm } @@ -682,11 +682,11 @@ fn get_self_ty(item: ebml::Doc) -> ast::self_ty_ { } } - let self_type_doc = reader::get_doc(item, tag_item_trait_method_self_ty); - let string = reader::doc_as_str(self_type_doc); + let explicit_self_doc = reader::get_doc(item, tag_item_trait_method_explicit_self); + let string = reader::doc_as_str(explicit_self_doc); - let self_ty_kind = string[0]; - match self_ty_kind as char { + let explicit_self_kind = string[0]; + match explicit_self_kind as char { 's' => { return ast::sty_static; } 'v' => { return ast::sty_value; } '@' => { return ast::sty_box(get_mutability(string[1])); } @@ -696,7 +696,7 @@ fn get_self_ty(item: ebml::Doc) -> ast::self_ty_ { return ast::sty_region(None, get_mutability(string[1])); } _ => { - fail!("unknown self type code: `%c`", self_ty_kind as char); + fail!("unknown self type code: `%c`", explicit_self_kind as char); } } } @@ -707,12 +707,12 @@ fn item_impl_methods(intr: @ident_interner, cdata: cmd, item: ebml::Doc, for reader::tagged_docs(item, tag_item_impl_method) |doc| { let m_did = reader::with_doc_data(doc, |d| parse_def_id(d)); let mth_item = lookup_item(m_did.node, cdata.data); - let self_ty = get_self_ty(mth_item); + let explicit_self = get_explicit_self(mth_item); rslt.push(@resolve::MethodInfo { did: translate_def_id(cdata, m_did), n_tps: item_ty_param_count(mth_item) - base_tps, ident: item_name(intr, mth_item), - self_type: self_ty}); + explicit_self: explicit_self}); } rslt } @@ -748,19 +748,19 @@ pub fn get_impls_for_mod(intr: @ident_interner, @result } -pub fn get_method_name_and_self_ty( +pub fn get_method_name_and_explicit_self( intr: @ident_interner, cdata: cmd, - id: ast::node_id) -> (ast::ident, ast::self_ty_) + id: ast::node_id) -> (ast::ident, ast::explicit_self_) { let method_doc = lookup_item(id, cdata.data); let name = item_name(intr, method_doc); - let self_ty = get_self_ty(method_doc); - (name, self_ty) + let explicit_self = get_explicit_self(method_doc); + (name, explicit_self) } pub fn get_method(intr: @ident_interner, cdata: cmd, id: ast::node_id, - tcx: ty::ctxt) -> ty::method + tcx: ty::ctxt) -> ty::Method { let method_doc = lookup_item(id, cdata.data); let def_id = item_def_id(method_doc, cdata); @@ -770,19 +770,20 @@ pub fn get_method(intr: @ident_interner, cdata: cmd, id: ast::node_id, let transformed_self_ty = doc_transformed_self_ty(method_doc, tcx, cdata); let fty = doc_method_fty(method_doc, tcx, cdata); let vis = item_visibility(method_doc); - let self_ty = get_self_ty(method_doc); - ty::method { - ident: name, - generics: ty::Generics { + let explicit_self = get_explicit_self(method_doc); + + ty::Method::new( + name, + ty::Generics { type_param_defs: type_param_defs, region_param: None }, - transformed_self_ty: transformed_self_ty, - fty: fty, - self_ty: self_ty, - vis: vis, - def_id: def_id - } + transformed_self_ty, + fty, + explicit_self, + vis, + def_id + ) } pub fn get_trait_method_def_ids(cdata: cmd, @@ -823,19 +824,20 @@ pub fn get_provided_trait_methods(intr: @ident_interner, cdata: cmd, }; let transformed_self_ty = doc_transformed_self_ty(mth, tcx, cdata); - let self_ty = get_self_ty(mth); - let ty_method = ty::method { - ident: name, - generics: ty::Generics { + let explicit_self = get_explicit_self(mth); + + let ty_method = ty::Method::new( + name, + ty::Generics { type_param_defs: type_param_defs, region_param: None }, - transformed_self_ty: transformed_self_ty, - fty: fty, - self_ty: self_ty, - vis: ast::public, - def_id: did - }; + transformed_self_ty, + fty, + explicit_self, + ast::public, + did + ); let provided_trait_method_info = ProvidedTraitMethodInfo { ty: ty_method, def_id: did @@ -1061,7 +1063,7 @@ fn get_attributes(md: ebml::Doc) -> ~[ast::attribute] { let meta_items = get_meta_items(attr_doc); // Currently it's only possible to have a single meta item on // an attribute - assert!((vec::len(meta_items) == 1u)); + assert!(meta_items.len() == 1u); let meta_item = meta_items[0]; attrs.push( codemap::spanned { diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index def24e5bc89..d27bfd081bc 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -366,7 +366,7 @@ fn encode_path(ecx: @EncodeContext, fn encode_reexported_static_method(ecx: @EncodeContext, ebml_w: &mut writer::Encoder, exp: &middle::resolve::Export2, - m: @ty::method) { + m: @ty::Method) { debug!("(encode static trait method) reexport '%s::%s'", *exp.name, *ecx.tcx.sess.str_of(m.ident)); ebml_w.start_tag(tag_items_data_item_reexport); @@ -389,7 +389,7 @@ fn encode_reexported_static_methods(ecx: @EncodeContext, Some(&ast_map::node_item(_, path)) => { if mod_path != *path { for methods.each |&m| { - if m.self_ty == ast::sty_static { + if m.explicit_self == ast::sty_static { encode_reexported_static_method(ecx, ebml_w, exp, m); @@ -486,11 +486,11 @@ fn encode_visibility(ebml_w: &mut writer::Encoder, visibility: visibility) { ebml_w.end_tag(); } -fn encode_self_type(ebml_w: &mut writer::Encoder, self_type: ast::self_ty_) { - ebml_w.start_tag(tag_item_trait_method_self_ty); +fn encode_explicit_self(ebml_w: &mut writer::Encoder, explicit_self: ast::explicit_self_) { + ebml_w.start_tag(tag_item_trait_method_explicit_self); // Encode the base self type. - match self_type { + match explicit_self { sty_static => { ebml_w.writer.write(&[ 's' as u8 ]); } @@ -625,7 +625,7 @@ fn encode_info_for_struct_ctor(ecx: @EncodeContext, fn encode_method_ty_fields(ecx: @EncodeContext, ebml_w: &mut writer::Encoder, - method_ty: &ty::method) { + method_ty: &ty::Method) { encode_def_id(ebml_w, method_ty.def_id); encode_name(ecx, ebml_w, method_ty.ident); encode_ty_type_param_defs(ebml_w, ecx, @@ -634,7 +634,7 @@ fn encode_method_ty_fields(ecx: @EncodeContext, encode_transformed_self_ty(ecx, ebml_w, method_ty.transformed_self_ty); encode_method_fty(ecx, ebml_w, &method_ty.fty); encode_visibility(ebml_w, method_ty.vis); - encode_self_type(ebml_w, method_ty.self_ty); + encode_explicit_self(ebml_w, method_ty.explicit_self); } fn encode_info_for_method(ecx: @EncodeContext, @@ -652,10 +652,10 @@ fn encode_info_for_method(ecx: @EncodeContext, ebml_w.start_tag(tag_items_data_item); let method_def_id = local_def(m.id); - let method_ty: @ty::method = ty::method(ecx.tcx, method_def_id); + let method_ty = ty::method(ecx.tcx, method_def_id); encode_method_ty_fields(ecx, ebml_w, method_ty); - match m.self_ty.node { + match m.explicit_self.node { ast::sty_static => { encode_family(ebml_w, purity_static_method_family(m.purity)); } @@ -948,7 +948,7 @@ fn encode_info_for_item(ecx: @EncodeContext, for ty::trait_method_def_ids(tcx, local_def(item.id)).eachi |i, &method_def_id| { assert!(method_def_id.crate == ast::local_crate); - let method_ty: @ty::method = ty::method(tcx, method_def_id); + let method_ty = ty::method(tcx, method_def_id); index.push(entry {val: method_def_id.node, pos: ebml_w.writer.tell()}); @@ -962,7 +962,7 @@ fn encode_info_for_item(ecx: @EncodeContext, trait_path.push(ast_map::path_name(item.ident)); encode_path(ecx, ebml_w, trait_path, ast_map::path_name(method_ty.ident)); - match method_ty.self_ty { + match method_ty.explicit_self { sty_static => { encode_family(ebml_w, purity_static_method_family( @@ -991,7 +991,7 @@ fn encode_info_for_item(ecx: @EncodeContext, // This is obviously a bogus assert but I don't think this // ever worked before anyhow...near as I can tell, before // we would emit two items. - if method_ty.self_ty == sty_static { + if method_ty.explicit_self == sty_static { tcx.sess.span_unimpl( item.span, fmt!("Method %s is both provided and static", diff --git a/src/librustc/metadata/loader.rs b/src/librustc/metadata/loader.rs index ba2e336b639..cfb2bd4b837 100644 --- a/src/librustc/metadata/loader.rs +++ b/src/librustc/metadata/loader.rs @@ -171,7 +171,7 @@ pub fn metadata_matches(extern_metas: &[@ast::meta_item], local_metas: &[@ast::meta_item]) -> bool { debug!("matching %u metadata requirements against %u items", - vec::len(local_metas), vec::len(extern_metas)); + local_metas.len(), extern_metas.len()); for local_metas.each |needed| { if !attr::contains(extern_metas, *needed) { diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs index cc9a18ea3a3..151ccad88ea 100644 --- a/src/librustc/metadata/tydecode.rs +++ b/src/librustc/metadata/tydecode.rs @@ -126,12 +126,6 @@ pub fn parse_trait_ref_data(data: @~[u8], crate_num: int, pos: uint, tcx: ty::ct parse_trait_ref(st, conv) } -pub fn parse_arg_data(data: @~[u8], crate_num: int, pos: uint, tcx: ty::ctxt, - conv: conv_did) -> ty::arg { - let st = parse_state_from_data(data, crate_num, pos, tcx); - parse_arg(st, conv) -} - fn parse_path(st: @mut PState) -> @ast::Path { let mut idents: ~[ast::ident] = ~[]; fn is_last(c: char) -> bool { return c == '(' || c == ':'; } @@ -471,12 +465,6 @@ fn parse_onceness(c: char) -> ast::Onceness { } } -fn parse_arg(st: @mut PState, conv: conv_did) -> ty::arg { - ty::arg { - ty: parse_ty(st, conv) - } -} - fn parse_closure_ty(st: @mut PState, conv: conv_did) -> ty::ClosureTy { let sigil = parse_sigil(st); let purity = parse_purity(next(st)); @@ -505,9 +493,9 @@ fn parse_bare_fn_ty(st: @mut PState, conv: conv_did) -> ty::BareFnTy { fn parse_sig(st: @mut PState, conv: conv_did) -> ty::FnSig { assert!((next(st) == '[')); - let mut inputs: ~[ty::arg] = ~[]; + let mut inputs = ~[]; while peek(st) != ']' { - inputs.push(ty::arg { ty: parse_ty(st, conv) }); + inputs.push(parse_ty(st, conv)); } st.pos += 1u; // eat the ']' let ret_ty = parse_ty(st, conv); @@ -519,7 +507,7 @@ fn parse_sig(st: @mut PState, conv: conv_did) -> ty::FnSig { // Rust metadata parsing pub fn parse_def_id(buf: &[u8]) -> ast::def_id { let mut colon_idx = 0u; - let len = vec::len(buf); + let len = buf.len(); while colon_idx < len && buf[colon_idx] != ':' as u8 { colon_idx += 1u; } if colon_idx == len { error!("didn't find ':' when parsing def id"); diff --git a/src/librustc/metadata/tyencode.rs b/src/librustc/metadata/tyencode.rs index e1b3230b0ff..2cb95e1a2fc 100644 --- a/src/librustc/metadata/tyencode.rs +++ b/src/librustc/metadata/tyencode.rs @@ -344,10 +344,6 @@ fn enc_sigil(w: @io::Writer, sigil: Sigil) { } } -pub fn enc_arg(w: @io::Writer, cx: @ctxt, arg: ty::arg) { - enc_ty(w, cx, arg.ty); -} - fn enc_purity(w: @io::Writer, p: purity) { match p { pure_fn => w.write_char('p'), @@ -389,8 +385,8 @@ fn enc_closure_ty(w: @io::Writer, cx: @ctxt, ft: &ty::ClosureTy) { fn enc_fn_sig(w: @io::Writer, cx: @ctxt, fsig: &ty::FnSig) { w.write_char('['); - for fsig.inputs.each |arg| { - enc_arg(w, cx, *arg); + for fsig.inputs.each |ty| { + enc_ty(w, cx, *ty); } w.write_char(']'); enc_ty(w, cx, fsig.output); diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 20a56ab0ee9..2996c4c8476 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -526,8 +526,8 @@ fn encode_method_map_entry(ecx: @e::EncodeContext, ebml_w: &mut writer::Encoder, mme: method_map_entry) { do ebml_w.emit_struct("method_map_entry", 3) |ebml_w| { - do ebml_w.emit_struct_field("self_arg", 0u) |ebml_w| { - ebml_w.emit_arg(ecx, mme.self_arg); + do ebml_w.emit_struct_field("self_ty", 0u) |ebml_w| { + ebml_w.emit_ty(ecx, mme.self_ty); } do ebml_w.emit_struct_field("explicit_self", 2u) |ebml_w| { mme.explicit_self.encode(ebml_w); @@ -546,14 +546,14 @@ impl read_method_map_entry_helper for reader::Decoder { -> method_map_entry { do self.read_struct("method_map_entry", 3) |this| { method_map_entry { - self_arg: this.read_struct_field("self_arg", 0, |this| { - this.read_arg(xcx) + self_ty: this.read_struct_field("self_ty", 0u, |this| { + this.read_ty(xcx) }), explicit_self: this.read_struct_field("explicit_self", 2, |this| { - let self_type: ast::self_ty_ = Decodable::decode(this); - self_type + let explicit_self: ast::explicit_self_ = Decodable::decode(this); + explicit_self }), origin: this.read_struct_field("origin", 1, |this| { let method_origin: method_origin = @@ -712,7 +712,6 @@ impl get_ty_str_ctxt for e::EncodeContext { } trait ebml_writer_helpers { - fn emit_arg(&mut self, ecx: @e::EncodeContext, arg: ty::arg); fn emit_ty(&mut self, ecx: @e::EncodeContext, ty: ty::t); fn emit_vstore(&mut self, ecx: @e::EncodeContext, vstore: ty::vstore); fn emit_tys(&mut self, ecx: @e::EncodeContext, tys: &[ty::t]); @@ -737,12 +736,6 @@ impl ebml_writer_helpers for writer::Encoder { } } - fn emit_arg(&mut self, ecx: @e::EncodeContext, arg: ty::arg) { - do self.emit_opaque |this| { - tyencode::enc_arg(this.writer, ecx.ty_str_ctxt(), arg); - } - } - fn emit_tys(&mut self, ecx: @e::EncodeContext, tys: &[ty::t]) { do self.emit_from_vec(tys) |this, ty| { this.emit_ty(ecx, *ty) @@ -943,7 +936,6 @@ impl doc_decoder_helpers for ebml::Doc { } trait ebml_decoder_decoder_helpers { - fn read_arg(&mut self, xcx: @ExtendedDecodeContext) -> ty::arg; fn read_ty(&mut self, xcx: @ExtendedDecodeContext) -> ty::t; fn read_tys(&mut self, xcx: @ExtendedDecodeContext) -> ~[ty::t]; fn read_type_param_def(&mut self, xcx: @ExtendedDecodeContext) @@ -958,17 +950,6 @@ trait ebml_decoder_decoder_helpers { } impl ebml_decoder_decoder_helpers for reader::Decoder { - fn read_arg(&mut self, xcx: @ExtendedDecodeContext) -> ty::arg { - do self.read_opaque |this, doc| { - tydecode::parse_arg_data( - doc.data, - xcx.dcx.cdata.cnum, - doc.start, - xcx.dcx.tcx, - |s, a| this.convert_def_id(xcx, s, a)) - } - } - fn read_ty(&mut self, xcx: @ExtendedDecodeContext) -> ty::t { // Note: regions types embed local node ids. In principle, we // should translate these node ids into the new decode diff --git a/src/librustc/middle/kind.rs b/src/librustc/middle/kind.rs index b220379e330..a891e8d3b7f 100644 --- a/src/librustc/middle/kind.rs +++ b/src/librustc/middle/kind.rs @@ -360,7 +360,7 @@ fn is_nullary_variant(cx: Context, ex: @expr) -> bool { expr_path(_) => { match cx.tcx.def_map.get_copy(&ex.id) { def_variant(edid, vdid) => { - vec::len(ty::enum_variant_with_id(cx.tcx, edid, vdid).args) == 0u + vec::len(ty::enum_variant_with_id(cx.tcx, edid, vdid).args) == 0u } _ => false } diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index 171048eac55..9995de24e8d 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -381,7 +381,7 @@ fn visit_fn(fk: &visit::fn_kind, // Add `this`, whether explicit or implicit. match *fk { fk_method(_, _, method) => { - match method.self_ty.node { + match method.explicit_self.node { sty_value | sty_region(*) | sty_box(_) | sty_uniq(_) => { fn_maps.add_variable(Arg(method.self_id, special_idents::self_)); diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs index 2c62130feb1..27b62738793 100644 --- a/src/librustc/middle/region.rs +++ b/src/librustc/middle/region.rs @@ -283,8 +283,8 @@ pub impl RegionMaps { let a_ancestors = ancestors_of(self, scope_a); let b_ancestors = ancestors_of(self, scope_b); - let mut a_index = vec::len(a_ancestors) - 1u; - let mut b_index = vec::len(b_ancestors) - 1u; + let mut a_index = a_ancestors.len() - 1u; + let mut b_index = b_ancestors.len() - 1u; // Here, ~[ab]_ancestors is a vector going from narrow to broad. // The end of each vector will be the item where the scope is diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs index a962ea07c54..9b864bd0ef2 100644 --- a/src/librustc/middle/resolve.rs +++ b/src/librustc/middle/resolve.rs @@ -10,7 +10,7 @@ use driver::session::Session; use metadata::csearch::{each_path, get_trait_method_def_ids}; -use metadata::csearch::get_method_name_and_self_ty; +use metadata::csearch::get_method_name_and_explicit_self; use metadata::csearch::get_static_methods_if_impl; use metadata::csearch::get_type_name_if_impl; use metadata::cstore::find_extern_mod_stmt_cnum; @@ -28,7 +28,7 @@ use syntax::ast::{def_const, def_foreign_mod, def_fn, def_id, def_label}; use syntax::ast::{def_local, def_mod, def_prim_ty, def_region, def_self}; use syntax::ast::{def_self_ty, def_static_method, def_struct, def_ty}; use syntax::ast::{def_ty_param, def_typaram_binder, def_trait}; -use syntax::ast::{def_upvar, def_use, def_variant, expr, expr_assign_op}; +use syntax::ast::{def_upvar, def_use, def_variant, explicit_self_, expr, expr_assign_op}; use syntax::ast::{expr_binary, expr_break, expr_field}; use syntax::ast::{expr_fn_block, expr_index, expr_method_call, expr_path}; use syntax::ast::{def_prim_ty, def_region, def_self, def_ty, def_ty_param}; @@ -45,7 +45,7 @@ use syntax::ast::{local, local_crate, lt, method, mul}; use syntax::ast::{named_field, ne, neg, node_id, pat, pat_enum, pat_ident}; use syntax::ast::{Path, pat_lit, pat_range, pat_struct}; use syntax::ast::{prim_ty, private, provided}; -use syntax::ast::{public, required, rem, self_ty_, shl, shr, stmt_decl}; +use syntax::ast::{public, required, rem, shl, shr, stmt_decl}; use syntax::ast::{struct_field, struct_variant_kind}; use syntax::ast::{sty_static, subtract, trait_ref, tuple_variant_kind, Ty}; use syntax::ast::{ty_bool, ty_char, ty_f, ty_f32, ty_f64, ty_float, ty_i}; @@ -96,7 +96,7 @@ pub struct MethodInfo { did: def_id, n_tps: uint, ident: ident, - self_type: self_ty_ + explicit_self: explicit_self_ } pub struct Impl { @@ -1203,7 +1203,7 @@ pub impl Resolver { // Bail out early if there are no static methods. let mut has_static_methods = false; for methods.each |method| { - match method.self_ty.node { + match method.explicit_self.node { sty_static => has_static_methods = true, _ => {} } @@ -1236,7 +1236,7 @@ pub impl Resolver { // For each static method... for methods.each |method| { - match method.self_ty.node { + match method.explicit_self.node { sty_static => { // Add the static method to the // module. @@ -1274,7 +1274,7 @@ pub impl Resolver { let mut has_static_methods = false; for (*methods).each |method| { let ty_m = trait_method_to_ty_method(method); - match ty_m.self_ty.node { + match ty_m.explicit_self.node { sty_static => { has_static_methods = true; break; @@ -1306,7 +1306,7 @@ pub impl Resolver { let ident = ty_m.ident; // Add it to the trait info if not static, // add it as a name in the trait module otherwise. - match ty_m.self_ty.node { + match ty_m.explicit_self.node { sty_static => { let def = def_static_method( local_def(ty_m.id), @@ -1612,9 +1612,9 @@ pub impl Resolver { def_id); let mut interned_method_names = HashSet::new(); for method_def_ids.each |&method_def_id| { - let (method_name, self_ty) = - get_method_name_and_self_ty(self.session.cstore, - method_def_id); + let (method_name, explicit_self) = + get_method_name_and_explicit_self(self.session.cstore, + method_def_id); debug!("(building reduced graph for \ external crate) ... adding \ @@ -1622,7 +1622,7 @@ pub impl Resolver { *self.session.str_of(method_name)); // Add it to the trait info if not static. - if self_ty != sty_static { + if explicit_self != sty_static { interned_method_names.insert(method_name); } } @@ -2058,7 +2058,8 @@ pub impl Resolver { self.resolve_single_import(module_, containing_module, target, - source); + source, + import_directive.span); } GlobImport => { let span = import_directive.span; @@ -2121,7 +2122,8 @@ pub impl Resolver { module_: @mut Module, containing_module: @mut Module, target: ident, - source: ident) + source: ident, + span: span) -> ResolveResult<()> { debug!("(resolving single import) resolving `%s` = `%s::%s` from \ `%s`", @@ -2325,14 +2327,14 @@ pub impl Resolver { } if resolve_fail { - self.session.err(fmt!("unresolved import: there is no `%s` in `%s`", - *self.session.str_of(source), - self.module_to_str(containing_module))); + self.session.span_err(span, fmt!("unresolved import: there is no `%s` in `%s`", + *self.session.str_of(source), + self.module_to_str(containing_module))); return Failed; } else if priv_fail { - self.session.err(fmt!("unresolved import: found `%s` in `%s` but it is private", - *self.session.str_of(source), - self.module_to_str(containing_module))); + self.session.span_err(span, fmt!("unresolved import: found `%s` in `%s` but it is \ + private", *self.session.str_of(source), + self.module_to_str(containing_module))); return Failed; } @@ -2593,7 +2595,18 @@ pub impl Resolver { let start_index; match module_prefix_result { Failed => { - self.session.span_err(span, ~"unresolved name"); + let mpath = self.idents_to_str(module_path); + match str::rfind(self.idents_to_str(module_path), |c| { c == ':' }) { + Some(idx) => { + self.session.span_err(span, fmt!("unresolved import: could not find `%s` \ + in `%s`", str::substr(mpath, idx, + mpath.len() - idx), + // idx - 1 to account for the extra + // colon + str::substr(mpath, 0, idx - 1))); + }, + None => (), + }; return Failed; } Indeterminate => { @@ -3774,7 +3787,7 @@ pub impl Resolver { outer_type_parameter_count, rib_kind); // we only have self ty if it is a non static method - let self_binding = match method.self_ty.node { + let self_binding = match method.explicit_self.node { sty_static => { NoSelfBinding } _ => { HasSelfBinding(method.self_id, false) } }; @@ -4693,7 +4706,7 @@ pub impl Resolver { } } - if vec::len(values) > 0 && + if values.len() > 0 && values[smallest] != uint::max_value && values[smallest] < str::len(name) + 2 && values[smallest] <= max_distance && diff --git a/src/librustc/middle/resolve_stage0.rs b/src/librustc/middle/resolve_stage0.rs index 2fc0fdca317..a404dcf7249 100644 --- a/src/librustc/middle/resolve_stage0.rs +++ b/src/librustc/middle/resolve_stage0.rs @@ -11,7 +11,7 @@ use driver::session; use driver::session::Session; use metadata::csearch::{each_path, get_trait_method_def_ids}; -use metadata::csearch::get_method_name_and_self_ty; +use metadata::csearch::get_method_name_and_explicit_self; use metadata::csearch::get_static_methods_if_impl; use metadata::csearch::get_type_name_if_impl; use metadata::cstore::find_extern_mod_stmt_cnum; @@ -46,7 +46,7 @@ use syntax::ast::{local, local_crate, lt, method, mul}; use syntax::ast::{named_field, ne, neg, node_id, pat, pat_enum, pat_ident}; use syntax::ast::{Path, pat_lit, pat_range, pat_struct}; use syntax::ast::{prim_ty, private, provided}; -use syntax::ast::{public, required, rem, self_ty_, shl, shr, stmt_decl}; +use syntax::ast::{public, required, rem, explicit_self_, shl, shr, stmt_decl}; use syntax::ast::{struct_field, struct_variant_kind}; use syntax::ast::{sty_static, subtract, trait_ref, tuple_variant_kind, Ty}; use syntax::ast::{ty_bool, ty_char, ty_f, ty_f32, ty_f64, ty_float, ty_i}; @@ -97,7 +97,7 @@ pub struct MethodInfo { did: def_id, n_tps: uint, ident: ident, - self_type: self_ty_ + explicit_self: explicit_self_ } pub struct Impl { @@ -1219,7 +1219,7 @@ pub impl Resolver { // Bail out early if there are no static methods. let mut has_static_methods = false; for methods.each |method| { - match method.self_ty.node { + match method.explicit_self.node { sty_static => has_static_methods = true, _ => {} } @@ -1252,7 +1252,7 @@ pub impl Resolver { // For each static method... for methods.each |method| { - match method.self_ty.node { + match method.explicit_self.node { sty_static => { // Add the static method to the // module. @@ -1290,7 +1290,7 @@ pub impl Resolver { let mut has_static_methods = false; for (*methods).each |method| { let ty_m = trait_method_to_ty_method(method); - match ty_m.self_ty.node { + match ty_m.explicit_self.node { sty_static => { has_static_methods = true; break; @@ -1322,7 +1322,7 @@ pub impl Resolver { let ident = ty_m.ident; // Add it to the trait info if not static, // add it as a name in the trait module otherwise. - match ty_m.self_ty.node { + match ty_m.explicit_self.node { sty_static => { let def = def_static_method( local_def(ty_m.id), @@ -1628,9 +1628,9 @@ pub impl Resolver { def_id); let mut interned_method_names = HashSet::new(); for method_def_ids.each |&method_def_id| { - let (method_name, self_ty) = - get_method_name_and_self_ty(self.session.cstore, - method_def_id); + let (method_name, explicit_self) = + get_method_name_and_explicit_self(self.session.cstore, + method_def_id); debug!("(building reduced graph for \ external crate) ... adding \ @@ -1638,7 +1638,7 @@ pub impl Resolver { *self.session.str_of(method_name)); // Add it to the trait info if not static. - if self_ty != sty_static { + if explicit_self != sty_static { interned_method_names.insert(method_name); } } @@ -3800,7 +3800,7 @@ pub impl Resolver { outer_type_parameter_count, rib_kind); // we only have self ty if it is a non static method - let self_binding = match method.self_ty.node { + let self_binding = match method.explicit_self.node { sty_static => { NoSelfBinding } _ => { HasSelfBinding(method.self_id, false) } }; @@ -4720,7 +4720,7 @@ pub impl Resolver { } } - if vec::len(values) > 0 && + if values.len() > 0 && values[smallest] != uint::max_value && values[smallest] < str::len(name) + 2 && values[smallest] <= max_distance && diff --git a/src/librustc/middle/trans/asm.rs b/src/librustc/middle/trans/asm.rs index cac9bdd186c..9211939cd2a 100644 --- a/src/librustc/middle/trans/asm.rs +++ b/src/librustc/middle/trans/asm.rs @@ -32,12 +32,9 @@ pub fn trans_inline_asm(bcx: block, ia: &ast::inline_asm) -> block { let outputs = do ia.outputs.map |&(c, out)| { constraints.push(copy *c); - let aoutty = ty::arg { - ty: expr_ty(bcx, out) - }; aoutputs.push(unpack_result!(bcx, { callee::trans_arg_expr(bcx, - aoutty, + expr_ty(bcx, out), ty::ByCopy, out, &mut cleanups, @@ -50,13 +47,9 @@ pub fn trans_inline_asm(bcx: block, ia: &ast::inline_asm) -> block { _ => fail!("Expression must be addr of") }; - let outty = ty::arg { - ty: expr_ty(bcx, e) - }; - unpack_result!(bcx, { callee::trans_arg_expr(bcx, - outty, + expr_ty(bcx, e), ty::ByCopy, e, &mut cleanups, @@ -75,13 +68,9 @@ pub fn trans_inline_asm(bcx: block, ia: &ast::inline_asm) -> block { let inputs = do ia.inputs.map |&(c, in)| { constraints.push(copy *c); - let inty = ty::arg { - ty: expr_ty(bcx, in) - }; - unpack_result!(bcx, { callee::trans_arg_expr(bcx, - inty, + expr_ty(bcx, in), ty::ByCopy, in, &mut cleanups, diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs index 7015a8b7f8b..e14d6d79ab5 100644 --- a/src/librustc/middle/trans/base.rs +++ b/src/librustc/middle/trans/base.rs @@ -1664,12 +1664,12 @@ pub fn new_fn_ctxt(ccx: @CrateContext, // the function's fn_ctxt). create_llargs_for_fn_args populates the llargs // field of the fn_ctxt with pub fn create_llargs_for_fn_args(cx: fn_ctxt, - ty_self: self_arg, + self_arg: self_arg, args: &[ast::arg]) -> ~[ValueRef] { let _icx = cx.insn_ctxt("create_llargs_for_fn_args"); - match ty_self { + match self_arg { impl_self(tt) => { cx.llself = Some(ValSelfData { v: cx.llenv, @@ -1701,7 +1701,7 @@ pub fn copy_args_to_allocas(fcx: fn_ctxt, bcx: block, args: &[ast::arg], raw_llargs: &[ValueRef], - arg_tys: &[ty::arg]) -> block { + arg_tys: &[ty::t]) -> block { let _icx = fcx.insn_ctxt("copy_args_to_allocas"); let mut bcx = bcx; @@ -1720,7 +1720,7 @@ pub fn copy_args_to_allocas(fcx: fn_ctxt, } for uint::range(0, arg_tys.len()) |arg_n| { - let arg_ty = &arg_tys[arg_n]; + let arg_ty = arg_tys[arg_n]; let raw_llarg = raw_llargs[arg_n]; let arg_id = args[arg_n].id; @@ -1732,15 +1732,15 @@ pub fn copy_args_to_allocas(fcx: fn_ctxt, // This alloca should be optimized away by LLVM's mem-to-reg pass in // the event it's not truly needed. // only by value if immediate: - let llarg = if datum::appropriate_mode(arg_ty.ty).is_by_value() { - let alloc = alloc_ty(bcx, arg_ty.ty); + let llarg = if datum::appropriate_mode(arg_ty).is_by_value() { + let alloc = alloc_ty(bcx, arg_ty); Store(bcx, raw_llarg, alloc); alloc } else { raw_llarg }; - add_clean(bcx, llarg, arg_ty.ty); + add_clean(bcx, llarg, arg_ty); bcx = _match::bind_irrefutable_pat(bcx, args[arg_n].pat, @@ -1801,7 +1801,7 @@ pub fn trans_closure(ccx: @CrateContext, decl: &ast::fn_decl, body: &ast::blk, llfndecl: ValueRef, - ty_self: self_arg, + self_arg: self_arg, param_substs: Option<@param_substs>, id: ast::node_id, impl_id: Option<ast::def_id>, @@ -1825,7 +1825,7 @@ pub fn trans_closure(ccx: @CrateContext, impl_id, param_substs, Some(body.span)); - let raw_llargs = create_llargs_for_fn_args(fcx, ty_self, decl.inputs); + let raw_llargs = create_llargs_for_fn_args(fcx, self_arg, decl.inputs); // Set the fixed stack segment flag if necessary. if attr::attrs_contains_name(attributes, "fixed_stack_segment") { @@ -1882,7 +1882,7 @@ pub fn trans_fn(ccx: @CrateContext, decl: &ast::fn_decl, body: &ast::blk, llfndecl: ValueRef, - ty_self: self_arg, + self_arg: self_arg, param_substs: Option<@param_substs>, id: ast::node_id, impl_id: Option<ast::def_id>, @@ -1890,8 +1890,8 @@ pub fn trans_fn(ccx: @CrateContext, let do_time = ccx.sess.trans_stats(); let start = if do_time { time::get_time() } else { time::Timespec::new(0, 0) }; - debug!("trans_fn(ty_self=%?, param_substs=%s)", - ty_self, + debug!("trans_fn(self_arg=%?, param_substs=%s)", + self_arg, param_substs.repr(ccx.tcx)); let _icx = ccx.insn_ctxt("trans_fn"); ccx.stats.n_fns += 1; @@ -1902,7 +1902,7 @@ pub fn trans_fn(ccx: @CrateContext, decl, body, llfndecl, - ty_self, + self_arg, param_substs, id, impl_id, @@ -1987,7 +1987,7 @@ pub fn trans_enum_variant(ccx: @CrateContext, Some(&local_mem(x)) => x, _ => fail!("trans_enum_variant: how do we know this works?"), }; - let arg_ty = arg_tys[i].ty; + let arg_ty = arg_tys[i]; memcpy_ty(bcx, lldestptr, llarg, arg_ty); } build_return(bcx); @@ -2061,7 +2061,7 @@ pub fn trans_tuple_struct(ccx: @CrateContext, local_mem") } }; - let arg_ty = arg_tys[i].ty; + let arg_ty = arg_tys[i]; memcpy_ty(bcx, lldestptr, llarg, arg_ty); } diff --git a/src/librustc/middle/trans/cabi.rs b/src/librustc/middle/trans/cabi.rs index 702d62f1363..e103bbc5de7 100644 --- a/src/librustc/middle/trans/cabi.rs +++ b/src/librustc/middle/trans/cabi.rs @@ -65,7 +65,7 @@ pub impl FnType { let mut llargvals = ~[]; let mut i = 0u; - let n = vec::len(arg_tys); + let n = arg_tys.len(); if self.sret { let llretptr = GEPi(bcx, llargbundle, [0u, n]); @@ -113,7 +113,7 @@ pub impl FnType { if self.sret || !ret_def { return; } - let n = vec::len(arg_tys); + let n = arg_tys.len(); // R** llretptr = &args->r; let llretptr = GEPi(bcx, llargbundle, [0u, n]); // R* llretloc = *llretptr; /* (args->r) */ @@ -149,7 +149,7 @@ pub impl FnType { }; let mut i = 0u; - let n = vec::len(atys); + let n = atys.len(); while i < n { let mut argval = get_param(llwrapfn, i + j); if attrs[i].is_some() { diff --git a/src/librustc/middle/trans/cabi_x86_64.rs b/src/librustc/middle/trans/cabi_x86_64.rs index 3a2ab74c33a..a44f203c7ab 100644 --- a/src/librustc/middle/trans/cabi_x86_64.rs +++ b/src/librustc/middle/trans/cabi_x86_64.rs @@ -50,7 +50,7 @@ fn is_sse(c: x86_64_reg_class) -> bool { } fn is_ymm(cls: &[x86_64_reg_class]) -> bool { - let len = vec::len(cls); + let len = cls.len(); return (len > 2u && is_sse(cls[0]) && cls[1] == sseup_class && @@ -223,8 +223,8 @@ fn classify_ty(ty: TypeRef) -> ~[x86_64_reg_class] { unsafe { let mut i = 0u; let llty = llvm::LLVMGetTypeKind(ty) as int; - let e = vec::len(cls); - if vec::len(cls) > 2u && + let e = cls.len(); + if cls.len() > 2u && (llty == 10 /* struct */ || llty == 11 /* array */) { if is_sse(cls[i]) { @@ -295,7 +295,7 @@ fn llreg_ty(cls: &[x86_64_reg_class]) -> TypeRef { unsafe { let mut tys = ~[]; let mut i = 0u; - let e = vec::len(cls); + let e = cls.len(); while i < e { match cls[i] { integer_class => { diff --git a/src/librustc/middle/trans/callee.rs b/src/librustc/middle/trans/callee.rs index 70a0a7d06d3..dc81a980588 100644 --- a/src/librustc/middle/trans/callee.rs +++ b/src/librustc/middle/trans/callee.rs @@ -674,7 +674,7 @@ pub enum AutorefArg { // temp_cleanups: cleanups that should run only if failure occurs before the // call takes place: pub fn trans_arg_expr(bcx: block, - formal_ty: ty::arg, + formal_arg_ty: ty::t, self_mode: ty::SelfMode, arg_expr: @ast::expr, temp_cleanups: &mut ~[ValueRef], @@ -683,9 +683,9 @@ pub fn trans_arg_expr(bcx: block, let _icx = bcx.insn_ctxt("trans_arg_expr"); let ccx = bcx.ccx(); - debug!("trans_arg_expr(formal_ty=(%s), self_mode=%?, arg_expr=%s, \ + debug!("trans_arg_expr(formal_arg_ty=(%s), self_mode=%?, arg_expr=%s, \ ret_flag=%?)", - formal_ty.ty.repr(bcx.tcx()), + formal_arg_ty.repr(bcx.tcx()), self_mode, arg_expr.repr(bcx.tcx()), ret_flag.map(|v| bcx.val_str(*v))); @@ -734,9 +734,9 @@ pub fn trans_arg_expr(bcx: block, // "undef" value, as such a value should never // be inspected. It's important for the value // to have type lldestty (the callee's expected type). - let llformal_ty = type_of::type_of(ccx, formal_ty.ty); + let llformal_arg_ty = type_of::type_of(ccx, formal_arg_ty); unsafe { - val = llvm::LLVMGetUndef(llformal_ty); + val = llvm::LLVMGetUndef(llformal_arg_ty); } } else { // FIXME(#3548) use the adjustments table @@ -784,16 +784,16 @@ pub fn trans_arg_expr(bcx: block, } } - if formal_ty.ty != arg_datum.ty { + if formal_arg_ty != arg_datum.ty { // this could happen due to e.g. subtyping - let llformal_ty = type_of::type_of_explicit_arg(ccx, &formal_ty); - let llformal_ty = match self_mode { - ty::ByRef => T_ptr(llformal_ty), - ty::ByCopy => llformal_ty, + let llformal_arg_ty = type_of::type_of_explicit_arg(ccx, &formal_arg_ty); + let llformal_arg_ty = match self_mode { + ty::ByRef => T_ptr(llformal_arg_ty), + ty::ByCopy => llformal_arg_ty, }; debug!("casting actual type (%s) to match formal (%s)", - bcx.val_str(val), bcx.llty_str(llformal_ty)); - val = PointerCast(bcx, val, llformal_ty); + bcx.val_str(val), bcx.llty_str(llformal_arg_ty)); + val = PointerCast(bcx, val, llformal_arg_ty); } } diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs index 0b56fe67f8a..d8252a449ba 100644 --- a/src/librustc/middle/trans/debuginfo.rs +++ b/src/librustc/middle/trans/debuginfo.rs @@ -785,7 +785,7 @@ fn create_ty(cx: @CrateContext, t: ty::t, span: span) cx.sess.span_bug(span, "debuginfo for rptr NYI") }, ty::ty_bare_fn(ref barefnty) => { - let inputs = do barefnty.sig.inputs.map |a| { a.ty }; + let inputs = barefnty.sig.inputs.map(|a| *a); let output = barefnty.sig.output; create_fn_ty(cx, t, inputs, output, span) }, diff --git a/src/librustc/middle/trans/foreign.rs b/src/librustc/middle/trans/foreign.rs index fcf5d05a744..5b1cae473f7 100644 --- a/src/librustc/middle/trans/foreign.rs +++ b/src/librustc/middle/trans/foreign.rs @@ -29,7 +29,7 @@ use middle::trans::machine; use middle::trans::type_of::*; use middle::trans::type_of; use middle::ty; -use middle::ty::{FnSig, arg}; +use middle::ty::FnSig; use util::ppaux::ty_to_str; use syntax::codemap::span; @@ -94,7 +94,7 @@ fn foreign_signature(ccx: @CrateContext, fn_sig: &ty::FnSig) * values by pointer like we do. */ - let llarg_tys = fn_sig.inputs.map(|arg| type_of(ccx, arg.ty)); + let llarg_tys = fn_sig.inputs.map(|arg_ty| type_of(ccx, *arg_ty)); let llret_ty = type_of::type_of(ccx, fn_sig.output); LlvmSignature { llarg_tys: llarg_tys, @@ -509,7 +509,7 @@ pub fn trans_foreign_mod(ccx: @CrateContext, llargbundle: ValueRef) { let _icx = bcx.insn_ctxt("foreign::wrap::build_args"); let ccx = bcx.ccx(); - let n = vec::len(tys.llsig.llarg_tys); + let n = tys.llsig.llarg_tys.len(); let implicit_args = first_real_arg; // return + env for uint::range(0, n) |i| { let mut llargval = get_param(llwrapfn, i + implicit_args); @@ -820,7 +820,7 @@ pub fn trans_intrinsic(ccx: @CrateContext, region: ty::re_bound(ty::br_anon(0)), sig: FnSig { bound_lifetime_names: opt_vec::Empty, - inputs: ~[ arg { ty: star_u8 } ], + inputs: ~[ star_u8 ], output: ty::mk_nil() } }); diff --git a/src/librustc/middle/trans/inline.rs b/src/librustc/middle/trans/inline.rs index e5c6244879d..10e019b2a37 100644 --- a/src/librustc/middle/trans/inline.rs +++ b/src/librustc/middle/trans/inline.rs @@ -99,14 +99,14 @@ pub fn maybe_instantiate_inline(ccx: @CrateContext, fn_id: ast::def_id, let path = vec::append( ty::item_path(ccx.tcx, impl_did), ~[path_name(mth.ident)]); - let self_kind = match mth.self_ty.node { + let self_kind = match mth.explicit_self.node { ast::sty_static => no_self, _ => { let self_ty = ty::node_id_to_type(ccx.tcx, mth.self_id); debug!("calling inline trans_fn with self_ty %s", ty_to_str(ccx.tcx, self_ty)); - match mth.self_ty.node { + match mth.explicit_self.node { ast::sty_value => impl_owned_self(self_ty), _ => impl_self(self_ty), } diff --git a/src/librustc/middle/trans/meth.rs b/src/librustc/middle/trans/meth.rs index d4856de2184..bdbb45bf275 100644 --- a/src/librustc/middle/trans/meth.rs +++ b/src/librustc/middle/trans/meth.rs @@ -25,7 +25,6 @@ use middle::trans::inline; use middle::trans::monomorphize; use middle::trans::type_of::*; use middle::ty; -use middle::ty::arg; use middle::typeck; use util::common::indenter; use util::ppaux::Repr; @@ -70,7 +69,12 @@ pub fn trans_impl(ccx: @CrateContext, path: path, name: ast::ident, } } - trans_method(ccx, path, *method, param_substs_opt, self_ty, llfn, + trans_method(ccx, + path, + *method, + param_substs_opt, + self_ty, + llfn, ast_util::local_def(id)); } } @@ -99,18 +103,17 @@ pub fn trans_method(ccx: @CrateContext, llfn: ValueRef, impl_id: ast::def_id) { // figure out how self is being passed - let self_arg = match method.self_ty.node { + let self_arg = match method.explicit_self.node { ast::sty_static => { no_self } _ => { // determine the (monomorphized) type that `self` maps to for // this method - let self_ty; - match base_self_ty { - None => self_ty = ty::node_id_to_type(ccx.tcx, method.self_id), - Some(provided_self_ty) => self_ty = provided_self_ty - } + let self_ty = match base_self_ty { + None => ty::node_id_to_type(ccx.tcx, method.self_id), + Some(provided_self_ty) => provided_self_ty, + }; let self_ty = match param_substs { None => self_ty, Some(@param_substs {tys: ref tys, _}) => { @@ -120,7 +123,7 @@ pub fn trans_method(ccx: @CrateContext, debug!("calling trans_fn with base_self_ty %s, self_ty %s", base_self_ty.repr(ccx.tcx), self_ty.repr(ccx.tcx)); - match method.self_ty.node { + match method.explicit_self.node { ast::sty_value => { impl_owned_self(self_ty) } @@ -151,12 +154,10 @@ pub fn trans_self_arg(bcx: block, let mut temp_cleanups = ~[]; // Compute the type of self. - let self_arg = arg { - ty: monomorphize_type(bcx, mentry.self_arg.ty) - }; + let self_ty = monomorphize_type(bcx, mentry.self_ty); let result = trans_arg_expr(bcx, - self_arg, + self_ty, mentry.self_mode, base, &mut temp_cleanups, @@ -589,7 +590,7 @@ pub fn trans_trait_callee(bcx: block, n_method: uint, self_expr: @ast::expr, store: ty::TraitStore, - explicit_self: ast::self_ty_) + explicit_self: ast::explicit_self_) -> Callee { //! // @@ -626,7 +627,7 @@ pub fn trans_trait_callee_from_llval(bcx: block, n_method: uint, llpair: ValueRef, store: ty::TraitStore, - explicit_self: ast::self_ty_) + explicit_self: ast::explicit_self_) -> Callee { //! // diff --git a/src/librustc/middle/trans/reflect.rs b/src/librustc/middle/trans/reflect.rs index 2183472d591..1141e0c007f 100644 --- a/src/librustc/middle/trans/reflect.rs +++ b/src/librustc/middle/trans/reflect.rs @@ -35,7 +35,7 @@ use syntax::parse::token::special_idents; pub struct Reflector { visitor_val: ValueRef, - visitor_methods: @~[@ty::method], + visitor_methods: @~[@ty::Method], final_bcx: block, tydesc_ty: TypeRef, bcx: block @@ -93,7 +93,7 @@ pub impl Reflector { let mth_ty = ty::mk_bare_fn(tcx, copy self.visitor_methods[mth_idx].fty); let v = self.visitor_val; - debug!("passing %u args:", vec::len(args)); + debug!("passing %u args:", args.len()); let bcx = self.bcx; for args.eachi |i, a| { debug!("arg %u: %s", i, val_str(bcx.ccx().tn, *a)); @@ -224,7 +224,7 @@ pub impl Reflector { let retval = if ty::type_is_bot(fty.sig.output) {0u} else {1u}; let extra = ~[self.c_uint(pureval), self.c_uint(sigilval), - self.c_uint(vec::len(fty.sig.inputs)), + self.c_uint(fty.sig.inputs.len()), self.c_uint(retval)]; self.visit(~"enter_fn", copy extra); // XXX: Bad copy. self.visit_sig(retval, &fty.sig); @@ -239,7 +239,7 @@ pub impl Reflector { let retval = if ty::type_is_bot(fty.sig.output) {0u} else {1u}; let extra = ~[self.c_uint(pureval), self.c_uint(sigilval), - self.c_uint(vec::len(fty.sig.inputs)), + self.c_uint(fty.sig.inputs.len()), self.c_uint(retval)]; self.visit(~"enter_fn", copy extra); // XXX: Bad copy. self.visit_sig(retval, &fty.sig); @@ -284,13 +284,8 @@ pub impl Reflector { let sym = mangle_internal_name_by_path_and_seq(ccx, sub_path, "get_disr"); - let args = [ - ty::arg { - ty: opaqueptrty - } - ]; - let llfty = type_of_fn(ccx, args, ty::mk_int()); + let llfty = type_of_fn(ccx, [opaqueptrty], ty::mk_int()); let llfdecl = decl_internal_cdecl_fn(ccx.llmod, sym, llfty); let arg = unsafe { llvm::LLVMGetParam(llfdecl, first_real_arg as c_uint) @@ -309,13 +304,13 @@ pub impl Reflector { llfdecl }; - let enum_args = ~[self.c_uint(vec::len(variants)), make_get_disr()] + let enum_args = ~[self.c_uint(variants.len()), make_get_disr()] + self.c_size_and_align(t); do self.bracketed(~"enum", enum_args) |this| { for variants.eachi |i, v| { let variant_args = ~[this.c_uint(i), this.c_int(v.disr_val), - this.c_uint(vec::len(v.args)), + this.c_uint(v.args.len()), this.c_slice(ccx.sess.str_of(v.name))]; do this.bracketed(~"enum_variant", variant_args) |this| { for v.args.eachi |j, a| { @@ -357,7 +352,7 @@ pub impl Reflector { let modeval = 5u; // "by copy" let extra = ~[self.c_uint(i), self.c_uint(modeval), - self.c_tydesc(arg.ty)]; + self.c_tydesc(*arg)]; self.visit(~"fn_input", extra); } let extra = ~[self.c_uint(retval), diff --git a/src/librustc/middle/trans/shape.rs b/src/librustc/middle/trans/shape.rs index 6ff9e1cfc57..31de1280741 100644 --- a/src/librustc/middle/trans/shape.rs +++ b/src/librustc/middle/trans/shape.rs @@ -18,7 +18,6 @@ use middle::trans::common::*; use middle::trans; use core::str; -use core::vec; pub struct Ctxt { next_tag_id: u16, @@ -71,6 +70,6 @@ pub fn add_u16(dest: &mut ~[u8], val: u16) { } pub fn add_substr(dest: &mut ~[u8], src: ~[u8]) { - add_u16(&mut *dest, vec::len(src) as u16); + add_u16(&mut *dest, src.len() as u16); *dest += src; } diff --git a/src/librustc/middle/trans/type_of.rs b/src/librustc/middle/trans/type_of.rs index b8e0b58f866..dfbebd90c29 100644 --- a/src/librustc/middle/trans/type_of.rs +++ b/src/librustc/middle/trans/type_of.rs @@ -19,21 +19,21 @@ use util::ppaux; use syntax::ast; -pub fn arg_is_indirect(_: @CrateContext, arg: &ty::arg) -> bool { - !ty::type_is_immediate(arg.ty) +pub fn arg_is_indirect(_: @CrateContext, arg_ty: &ty::t) -> bool { + !ty::type_is_immediate(*arg_ty) } -pub fn type_of_explicit_arg(ccx: @CrateContext, arg: &ty::arg) -> TypeRef { - let llty = type_of(ccx, arg.ty); - if arg_is_indirect(ccx, arg) {T_ptr(llty)} else {llty} +pub fn type_of_explicit_arg(ccx: @CrateContext, arg_ty: &ty::t) -> TypeRef { + let llty = type_of(ccx, *arg_ty); + if arg_is_indirect(ccx, arg_ty) {T_ptr(llty)} else {llty} } pub fn type_of_explicit_args(ccx: @CrateContext, - inputs: &[ty::arg]) -> ~[TypeRef] { - inputs.map(|arg| type_of_explicit_arg(ccx, arg)) + inputs: &[ty::t]) -> ~[TypeRef] { + inputs.map(|arg_ty| type_of_explicit_arg(ccx, arg_ty)) } -pub fn type_of_fn(cx: @CrateContext, inputs: &[ty::arg], output: ty::t) +pub fn type_of_fn(cx: @CrateContext, inputs: &[ty::t], output: ty::t) -> TypeRef { unsafe { let mut atys: ~[TypeRef] = ~[]; diff --git a/src/librustc/middle/trans/type_use.rs b/src/librustc/middle/trans/type_use.rs index c15c31055c3..4a8adfba11c 100644 --- a/src/librustc/middle/trans/type_use.rs +++ b/src/librustc/middle/trans/type_use.rs @@ -78,7 +78,7 @@ pub fn type_uses_for(ccx: @CrateContext, fn_id: def_id, n_tps: uint) ty::ty_bare_fn(ty::BareFnTy {sig: ref sig, _}) | ty::ty_closure(ty::ClosureTy {sig: ref sig, _}) => { for sig.inputs.each |arg| { - type_needs(cx, use_repr, arg.ty); + type_needs(cx, use_repr, *arg); } } _ => () @@ -331,18 +331,16 @@ pub fn mark_for_expr(cx: Context, e: @expr) { node_type_needs(cx, use_tydesc, val.id); } expr_call(f, _, _) => { - for vec::each(ty::ty_fn_args(ty::node_id_to_type(cx.ccx.tcx, - f.id))) |a| { - type_needs(cx, use_repr, a.ty); + for ty::ty_fn_args(ty::node_id_to_type(cx.ccx.tcx, f.id)).each |a| { + type_needs(cx, use_repr, *a); } } expr_method_call(rcvr, _, _, _, _) => { let base_ty = ty::node_id_to_type(cx.ccx.tcx, rcvr.id); type_needs(cx, use_repr, ty::type_autoderef(cx.ccx.tcx, base_ty)); - for ty::ty_fn_args(ty::node_id_to_type(cx.ccx.tcx, - e.callee_id)).each |a| { - type_needs(cx, use_repr, a.ty); + for ty::ty_fn_args(ty::node_id_to_type(cx.ccx.tcx, e.callee_id)).each |a| { + type_needs(cx, use_repr, *a); } mark_for_method_call(cx, e.id, e.callee_id); } diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index fbb84751d03..4ee2c5b0100 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -47,27 +47,49 @@ use syntax; // Data types -#[deriving(Eq, IterBytes)] -pub struct arg { - ty: t -} - #[deriving(Eq)] pub struct field { ident: ast::ident, mt: mt } -pub struct method { +pub struct Method { ident: ast::ident, generics: ty::Generics, transformed_self_ty: Option<ty::t>, fty: BareFnTy, - self_ty: ast::self_ty_, + explicit_self: ast::explicit_self_, vis: ast::visibility, def_id: ast::def_id } +pub impl Method { + fn new(ident: ast::ident, + generics: ty::Generics, + transformed_self_ty: Option<ty::t>, + fty: BareFnTy, + explicit_self: ast::explicit_self_, + vis: ast::visibility, + def_id: ast::def_id) -> Method { + // Check the invariants. + if explicit_self == ast::sty_static { + assert!(transformed_self_ty.is_none()); + } else { + assert!(transformed_self_ty.is_some()); + } + + Method { + ident: ident, + generics: generics, + transformed_self_ty: transformed_self_ty, + fty: fty, + explicit_self: explicit_self, + vis: vis, + def_id: def_id + } + } +} + #[deriving(Eq)] pub struct mt { ty: t, @@ -259,13 +281,13 @@ struct ctxt_ { node_type_substs: @mut HashMap<node_id, ~[t]>, // Maps from a method to the method "descriptor" - methods: @mut HashMap<def_id, @method>, + methods: @mut HashMap<def_id, @Method>, // Maps from a trait def-id to a list of the def-ids of its methods trait_method_def_ids: @mut HashMap<def_id, @~[def_id]>, // A cache for the trait_methods() routine - trait_methods_cache: @mut HashMap<def_id, @~[@method]>, + trait_methods_cache: @mut HashMap<def_id, @~[@Method]>, trait_refs: @mut HashMap<node_id, @TraitRef>, trait_defs: @mut HashMap<def_id, @TraitDef>, @@ -392,7 +414,7 @@ pub struct ClosureTy { #[deriving(Eq)] pub struct FnSig { bound_lifetime_names: OptVec<ast::ident>, - inputs: ~[arg], + inputs: ~[t], output: t } @@ -1107,14 +1129,14 @@ fn mk_t(cx: ctxt, st: sty) -> t { } &ty_tup(ref ts) => for ts.each |tt| { flags |= get(*tt).flags; }, &ty_bare_fn(ref f) => { - for f.sig.inputs.each |a| { flags |= get(a.ty).flags; } + for f.sig.inputs.each |a| { flags |= get(*a).flags; } flags |= get(f.sig.output).flags; // T -> _|_ is *not* _|_ ! flags &= !(has_ty_bot as uint); } &ty_closure(ref f) => { flags |= rflags(f.region); - for f.sig.inputs.each |a| { flags |= get(a.ty).flags; } + for f.sig.inputs.each |a| { flags |= get(*a).flags; } flags |= get(f.sig.output).flags; // T -> _|_ is *not* _|_ ! flags &= !(has_ty_bot as uint); @@ -1298,7 +1320,7 @@ pub fn mk_bare_fn(cx: ctxt, fty: BareFnTy) -> t { } pub fn mk_ctor_fn(cx: ctxt, input_tys: &[ty::t], output: ty::t) -> t { - let input_args = input_tys.map(|t| arg { ty: *t }); + let input_args = input_tys.map(|t| *t); mk_bare_fn(cx, BareFnTy { purity: ast::pure_fn, @@ -1372,11 +1394,11 @@ pub fn maybe_walk_ty(ty: t, f: &fn(t) -> bool) { } ty_tup(ref ts) => { for ts.each |tt| { maybe_walk_ty(*tt, f); } } ty_bare_fn(ref ft) => { - for ft.sig.inputs.each |a| { maybe_walk_ty(a.ty, f); } + for ft.sig.inputs.each |a| { maybe_walk_ty(*a, f); } maybe_walk_ty(ft.sig.output, f); } ty_closure(ref ft) => { - for ft.sig.inputs.each |a| { maybe_walk_ty(a.ty, f); } + for ft.sig.inputs.each |a| { maybe_walk_ty(*a, f); } maybe_walk_ty(ft.sig.output, f); } } @@ -1387,11 +1409,7 @@ pub fn fold_sty_to_ty(tcx: ty::ctxt, sty: &sty, foldop: &fn(t) -> t) -> t { } pub fn fold_sig(sig: &FnSig, fldop: &fn(t) -> t) -> FnSig { - let args = do sig.inputs.map |arg| { - arg { - ty: fldop(arg.ty) - } - }; + let args = sig.inputs.map(|arg| fldop(*arg)); FnSig { bound_lifetime_names: copy sig.bound_lifetime_names, @@ -2616,7 +2634,7 @@ pub fn deref_sty(cx: ctxt, sty: &sty, explicit: bool) -> Option<mt> { ty_enum(did, ref substs) => { let variants = enum_variants(cx, did); - if vec::len(*variants) == 1u && vec::len(variants[0].args) == 1u { + if (*variants).len() == 1u && variants[0].args.len() == 1u { let v_t = subst(cx, substs, variants[0].args[0]); Some(mt {ty: v_t, mutbl: ast::m_imm}) } else { @@ -2999,7 +3017,7 @@ pub fn ty_fn_sig(fty: t) -> FnSig { } // Type accessors for substructures of types -pub fn ty_fn_args(fty: t) -> ~[arg] { +pub fn ty_fn_args(fty: t) -> ~[t] { match get(fty).sty { ty_bare_fn(ref f) => copy f.sig.inputs, ty_closure(ref f) => copy f.sig.inputs, @@ -3103,7 +3121,7 @@ pub fn replace_closure_return_type(tcx: ctxt, fn_type: t, ret_type: t) -> t { // Returns a vec of all the input and output types of fty. pub fn tys_in_fn_sig(sig: &FnSig) -> ~[t] { - vec::append_one(sig.inputs.map(|a| a.ty), sig.output) + vec::append_one(sig.inputs.map(|a| *a), sig.output) } // Type accessors for AST nodes @@ -3507,7 +3525,7 @@ pub fn field_idx_strict(tcx: ty::ctxt, id: ast::ident, fields: &[field]) fields.map(|f| tcx.sess.str_of(f.ident)))); } -pub fn method_idx(id: ast::ident, meths: &[@method]) -> Option<uint> { +pub fn method_idx(id: ast::ident, meths: &[@Method]) -> Option<uint> { vec::position(meths, |m| m.ident == id) } @@ -3831,12 +3849,12 @@ fn lookup_locally_or_in_crate_store<V:Copy>( return v; } -pub fn trait_method(cx: ctxt, trait_did: ast::def_id, idx: uint) -> @method { +pub fn trait_method(cx: ctxt, trait_did: ast::def_id, idx: uint) -> @Method { let method_def_id = ty::trait_method_def_ids(cx, trait_did)[idx]; ty::method(cx, method_def_id) } -pub fn trait_methods(cx: ctxt, trait_did: ast::def_id) -> @~[@method] { +pub fn trait_methods(cx: ctxt, trait_did: ast::def_id) -> @~[@Method] { match cx.trait_methods_cache.find(&trait_did) { Some(&methods) => methods, None => { @@ -3848,7 +3866,7 @@ pub fn trait_methods(cx: ctxt, trait_did: ast::def_id) -> @~[@method] { } } -pub fn method(cx: ctxt, id: ast::def_id) -> @method { +pub fn method(cx: ctxt, id: ast::def_id) -> @Method { lookup_locally_or_in_crate_store( "methods", id, cx.methods, || @csearch::get_method(cx, id)) @@ -4061,7 +4079,7 @@ pub fn enum_variants(cx: ctxt, id: ast::def_id) -> @~[VariantInfo] { let ctor_ty = node_id_to_type(cx, variant.node.id); let arg_tys = { if args.len() > 0u { - ty_fn_args(ctor_ty).map(|a| a.ty) + ty_fn_args(ctor_ty).map(|a| *a) } else { ~[] } diff --git a/src/librustc/middle/typeck/astconv.rs b/src/librustc/middle/typeck/astconv.rs index 469e31d0c49..de6064b0a31 100644 --- a/src/librustc/middle/typeck/astconv.rs +++ b/src/librustc/middle/typeck/astconv.rs @@ -53,7 +53,7 @@ */ use middle::const_eval; -use middle::ty::{arg, substs}; +use middle::ty::{substs}; use middle::ty::{ty_param_substs_and_ty}; use middle::ty; use middle::typeck::rscope::in_binding_rscope; @@ -501,16 +501,12 @@ pub fn ty_of_arg<AC:AstConv, this: &AC, rscope: &RS, a: ast::arg, - expected_ty: Option<ty::arg>) - -> ty::arg { - let ty = match a.ty.node { - ast::ty_infer if expected_ty.is_some() => expected_ty.get().ty, + expected_ty: Option<ty::t>) + -> ty::t { + match a.ty.node { + ast::ty_infer if expected_ty.is_some() => expected_ty.get(), ast::ty_infer => this.ty_infer(a.ty.span), _ => ast_ty_to_ty(this, rscope, a.ty), - }; - - arg { - ty: ty } } @@ -546,7 +542,7 @@ pub fn bound_lifetimes<AC:AstConv>( struct SelfInfo { untransformed_self_ty: ty::t, - self_transform: ast::self_ty + explicit_self: ast::explicit_self } pub fn ty_of_method<AC:AstConv,RS:region_scope + Copy + 'static>( @@ -555,12 +551,12 @@ pub fn ty_of_method<AC:AstConv,RS:region_scope + Copy + 'static>( purity: ast::purity, lifetimes: &OptVec<ast::Lifetime>, untransformed_self_ty: ty::t, - self_transform: ast::self_ty, + explicit_self: ast::explicit_self, decl: &ast::fn_decl) -> (Option<ty::t>, ty::BareFnTy) { let self_info = SelfInfo { untransformed_self_ty: untransformed_self_ty, - self_transform: self_transform + explicit_self: explicit_self }; let (a, b) = ty_of_method_or_bare_fn( this, rscope, purity, AbiSet::Rust(), lifetimes, Some(&self_info), decl); @@ -621,7 +617,7 @@ fn ty_of_method_or_bare_fn<AC:AstConv,RS:region_scope + Copy + 'static>( rscope: &RS, self_info: &SelfInfo) -> Option<ty::t> { - match self_info.self_transform.node { + match self_info.explicit_self.node { ast::sty_static => None, ast::sty_value => { Some(self_info.untransformed_self_ty) @@ -629,7 +625,7 @@ fn ty_of_method_or_bare_fn<AC:AstConv,RS:region_scope + Copy + 'static>( ast::sty_region(lifetime, mutability) => { let region = ast_region_to_region(this, rscope, - self_info.self_transform.span, + self_info.explicit_self.span, lifetime); Some(ty::mk_rptr(this.tcx(), region, ty::mt {ty: self_info.untransformed_self_ty, diff --git a/src/librustc/middle/typeck/check/method.rs b/src/librustc/middle/typeck/check/method.rs index 24edf4a6033..9e8103f4527 100644 --- a/src/librustc/middle/typeck/check/method.rs +++ b/src/librustc/middle/typeck/check/method.rs @@ -170,7 +170,7 @@ pub struct LookupContext<'self> { pub struct Candidate { rcvr_ty: ty::t, rcvr_substs: ty::substs, - method_ty: @ty::method, + method_ty: @ty::Method, origin: method_origin, } @@ -381,7 +381,7 @@ pub impl<'self> LookupContext<'self> { let trait_methods = ty::trait_methods(tcx, bound_trait_ref.def_id); let pos = { match trait_methods.position(|m| { - m.self_ty != ast::sty_static && + m.explicit_self != ast::sty_static && m.ident == self.m_name }) { Some(pos) => pos, @@ -469,7 +469,7 @@ pub impl<'self> LookupContext<'self> { did: def_id, substs: &ty::substs) { struct MethodInfo { - method_ty: @ty::method, + method_ty: @ty::Method, trait_def_id: ast::def_id, index: uint } @@ -830,10 +830,10 @@ pub impl<'self> LookupContext<'self> { } fn search_for_method(&self, - self_ty: ty::t) + rcvr_ty: ty::t) -> Option<method_map_entry> { - debug!("search_for_method(self_ty=%s)", self.ty_to_str(self_ty)); + debug!("search_for_method(rcvr_ty=%s)", self.ty_to_str(rcvr_ty)); let _indenter = indenter(); // I am not sure that inherent methods should have higher @@ -841,7 +841,7 @@ pub impl<'self> LookupContext<'self> { // existing code. debug!("searching inherent candidates"); - match self.consider_candidates(self_ty, self.inherent_candidates) { + match self.consider_candidates(rcvr_ty, self.inherent_candidates) { None => {} Some(mme) => { return Some(mme); @@ -849,7 +849,7 @@ pub impl<'self> LookupContext<'self> { } debug!("searching extension candidates"); - match self.consider_candidates(self_ty, self.extension_candidates) { + match self.consider_candidates(rcvr_ty, self.extension_candidates) { None => { return None; } @@ -860,12 +860,12 @@ pub impl<'self> LookupContext<'self> { } fn consider_candidates(&self, - self_ty: ty::t, + rcvr_ty: ty::t, candidates: &mut ~[Candidate]) -> Option<method_map_entry> { let relevant_candidates = - candidates.filter_to_vec(|c| self.is_relevant(self_ty, c)); + candidates.filter_to_vec(|c| self.is_relevant(rcvr_ty, c)); let relevant_candidates = self.merge_candidates(relevant_candidates); @@ -882,7 +882,7 @@ pub impl<'self> LookupContext<'self> { } } - Some(self.confirm_candidate(self_ty, &relevant_candidates[0])) + Some(self.confirm_candidate(rcvr_ty, &relevant_candidates[0])) } fn merge_candidates(&self, candidates: &[Candidate]) -> ~[Candidate] { @@ -932,7 +932,7 @@ pub impl<'self> LookupContext<'self> { } fn confirm_candidate(&self, - self_ty: ty::t, + rcvr_ty: ty::t, candidate: &Candidate) -> method_map_entry { @@ -948,11 +948,11 @@ pub impl<'self> LookupContext<'self> { self.enforce_drop_trait_limitations(candidate); // static methods should never have gotten this far: - assert!(candidate.method_ty.self_ty != sty_static); + assert!(candidate.method_ty.explicit_self != sty_static); let transformed_self_ty = match candidate.origin { method_trait(*) => { - match candidate.method_ty.self_ty { + match candidate.method_ty.explicit_self { sty_region(*) => { // FIXME(#5762) again, preserving existing // behavior here which (for &self) desires @@ -1033,7 +1033,7 @@ pub impl<'self> LookupContext<'self> { let fty = ty::mk_bare_fn(tcx, ty::BareFnTy {sig: fn_sig, ..bare_fn_ty}); debug!("after replacing bound regions, fty=%s", self.ty_to_str(fty)); - let self_mode = get_mode_from_self_type(candidate.method_ty.self_ty); + let self_mode = get_mode_from_explicit_self(candidate.method_ty.explicit_self); // before we only checked whether self_ty could be a subtype // of rcvr_ty; now we actually make it so (this may cause @@ -1041,11 +1041,11 @@ pub impl<'self> LookupContext<'self> { // nothing has changed in the meantime, this unification // should never fail. match self.fcx.mk_subty(false, self.self_expr.span, - self_ty, transformed_self_ty) { + rcvr_ty, transformed_self_ty) { result::Ok(_) => (), result::Err(_) => { self.bug(fmt!("%s was a subtype of %s but now is not?", - self.ty_to_str(self_ty), + self.ty_to_str(rcvr_ty), self.ty_to_str(transformed_self_ty))); } } @@ -1053,11 +1053,9 @@ pub impl<'self> LookupContext<'self> { self.fcx.write_ty(self.callee_id, fty); self.fcx.write_substs(self.callee_id, all_substs); method_map_entry { - self_arg: arg { - ty: candidate.rcvr_ty, - }, + self_ty: candidate.rcvr_ty, self_mode: self_mode, - explicit_self: candidate.method_ty.self_ty, + explicit_self: candidate.method_ty.explicit_self, origin: candidate.origin, } } @@ -1116,9 +1114,11 @@ pub impl<'self> LookupContext<'self> { } } - fn is_relevant(&self, self_ty: ty::t, candidate: &Candidate) -> bool { - debug!("is_relevant(self_ty=%s, candidate=%s)", - self.ty_to_str(self_ty), self.cand_to_str(candidate)); + // `rcvr_ty` is the type of the expression. It may be a subtype of a + // candidate method's `self_ty`. + fn is_relevant(&self, rcvr_ty: ty::t, candidate: &Candidate) -> bool { + debug!("is_relevant(rcvr_ty=%s, candidate=%s)", + self.ty_to_str(rcvr_ty), self.cand_to_str(candidate)); // Check for calls to object methods. We resolve these differently. // @@ -1126,7 +1126,7 @@ pub impl<'self> LookupContext<'self> { // on an @Trait object here and so forth match candidate.origin { method_trait(*) => { - match candidate.method_ty.self_ty { + match candidate.method_ty.explicit_self { sty_static | sty_value => { return false; } @@ -1136,7 +1136,7 @@ pub impl<'self> LookupContext<'self> { // an &@Trait receiver (wacky) } sty_box(*) | sty_uniq(*) => { - return self.fcx.can_mk_subty(self_ty, + return self.fcx.can_mk_subty(rcvr_ty, candidate.rcvr_ty).is_ok(); } }; @@ -1144,17 +1144,17 @@ pub impl<'self> LookupContext<'self> { _ => {} } - return match candidate.method_ty.self_ty { + return match candidate.method_ty.explicit_self { sty_static => { false } sty_value => { - self.fcx.can_mk_subty(self_ty, candidate.rcvr_ty).is_ok() + self.fcx.can_mk_subty(rcvr_ty, candidate.rcvr_ty).is_ok() } sty_region(_, m) => { - match ty::get(self_ty).sty { + match ty::get(rcvr_ty).sty { ty::ty_rptr(_, mt) => { mutability_matches(mt.mutbl, m) && self.fcx.can_mk_subty(mt.ty, candidate.rcvr_ty).is_ok() @@ -1165,7 +1165,7 @@ pub impl<'self> LookupContext<'self> { } sty_box(m) => { - match ty::get(self_ty).sty { + match ty::get(rcvr_ty).sty { ty::ty_box(mt) => { mutability_matches(mt.mutbl, m) && self.fcx.can_mk_subty(mt.ty, candidate.rcvr_ty).is_ok() @@ -1176,7 +1176,7 @@ pub impl<'self> LookupContext<'self> { } sty_uniq(m) => { - match ty::get(self_ty).sty { + match ty::get(rcvr_ty).sty { ty::ty_uniq(mt) => { mutability_matches(mt.mutbl, m) && self.fcx.can_mk_subty(mt.ty, candidate.rcvr_ty).is_ok() @@ -1301,8 +1301,8 @@ pub impl<'self> LookupContext<'self> { } } -pub fn get_mode_from_self_type(self_type: ast::self_ty_) -> SelfMode { - match self_type { +pub fn get_mode_from_explicit_self(explicit_self: ast::explicit_self_) -> SelfMode { + match explicit_self { sty_value => ty::ByCopy, _ => ty::ByRef, } diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs index fd511b6fc53..548b9e454ce 100644 --- a/src/librustc/middle/typeck/check/mod.rs +++ b/src/librustc/middle/typeck/check/mod.rs @@ -81,7 +81,7 @@ use middle::pat_util::pat_id_map; use middle::pat_util; use middle::ty::{FnSig, VariantInfo_}; use middle::ty::{ty_param_bounds_and_ty, ty_param_substs_and_ty}; -use middle::ty::{substs, arg, param_ty}; +use middle::ty::{substs, param_ty}; use middle::ty; use middle::typeck::astconv::AstConv; use middle::typeck::astconv::{ast_region_to_region, ast_ty_to_ty}; @@ -352,7 +352,7 @@ pub fn check_fn(ccx: @mut CrateCtxt, relate_free_regions(tcx, opt_self_info.map(|s| s.self_ty), &fn_sig); - let arg_tys = fn_sig.inputs.map(|a| a.ty); + let arg_tys = fn_sig.inputs.map(|a| *a); let ret_ty = fn_sig.output; debug!("check_fn(arg_tys=%?, ret_ty=%?, opt_self_ty=%?)", @@ -527,7 +527,7 @@ pub fn check_method(ccx: @mut CrateCtxt, let opt_self_info = method_ty.transformed_self_ty.map(|&ty| { SelfInfo {self_ty: ty, self_id: method.self_id, - span: method.self_ty.span} + span: method.explicit_self.span} }); check_bare_fn( @@ -1192,7 +1192,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt, fn check_argument_types( fcx: @mut FnCtxt, sp: span, - fn_inputs: &[ty::arg], + fn_inputs: &[ty::t], callee_expr: @ast::expr, args: &[@ast::expr], sugar: ast::CallSugar, @@ -1211,7 +1211,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt, let supplied_arg_count = args.len(); let expected_arg_count = fn_inputs.len(); let formal_tys = if expected_arg_count == supplied_arg_count { - fn_inputs.map(|a| a.ty) + fn_inputs.map(|a| *a) } else { let suffix = match sugar { ast::NoSugar => "", @@ -1287,8 +1287,8 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt, } } - fn err_args(len: uint) -> ~[ty::arg] { - vec::from_fn(len, |_| ty::arg { ty: ty::mk_err() }) + fn err_args(len: uint) -> ~[ty::t] { + vec::from_fn(len, |_| ty::mk_err()) } // A generic function for checking assignment expressions @@ -1701,11 +1701,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt, let fty = if error_happened { fty_sig = FnSig { bound_lifetime_names: opt_vec::Empty, - inputs: fn_ty.sig.inputs.map(|_| { - arg { - ty: ty::mk_err() - } - }), + inputs: fn_ty.sig.inputs.map(|_| ty::mk_err()), output: ty::mk_err() }; ty::mk_err() @@ -3132,24 +3128,23 @@ pub fn check_enum_variants(ccx: @mut CrateCtxt, } disr_vals.push(*disr_val); let ctor_ty = ty::node_id_to_type(ccx.tcx, v.node.id); - let arg_tys; let this_disr_val = *disr_val; *disr_val += 1; - match v.node.kind { + let arg_tys = match v.node.kind { ast::tuple_variant_kind(ref args) if args.len() > 0u => { - arg_tys = Some(ty::ty_fn_args(ctor_ty).map(|a| a.ty)); + Some(ty::ty_fn_args(ctor_ty).map(|a| *a)) } ast::tuple_variant_kind(_) => { - arg_tys = Some(~[]); + Some(~[]) } ast::struct_variant_kind(_) => { - arg_tys = Some(ty::lookup_struct_fields( + Some(ty::lookup_struct_fields( ccx.tcx, local_def(v.node.id)).map(|cf| - ty::node_id_to_type(ccx.tcx, cf.id.node))); + ty::node_id_to_type(ccx.tcx, cf.id.node))) } - } + }; match arg_tys { None => {} @@ -3281,7 +3276,7 @@ pub fn instantiate_path(fcx: @mut FnCtxt, debug!(">>> instantiate_path"); let ty_param_count = tpt.generics.type_param_defs.len(); - let ty_substs_len = vec::len(pth.types); + let ty_substs_len = pth.types.len(); debug!("ty_param_count=%? ty_substs_len=%?", ty_param_count, @@ -3454,11 +3449,6 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) { fn param(ccx: @mut CrateCtxt, n: uint) -> ty::t { ty::mk_param(ccx.tcx, n, local_def(0)) } - fn arg(ty: ty::t) -> ty::arg { - arg { - ty: ty - } - } let tcx = ccx.tcx; let (n_tps, inputs, output) = match *ccx.tcx.sess.str_of(it.ident) { @@ -3466,15 +3456,13 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) { ~"pref_align_of" | ~"min_align_of" => (1u, ~[], ty::mk_uint()), ~"init" => (1u, ~[], param(ccx, 0u)), ~"uninit" => (1u, ~[], param(ccx, 0u)), - ~"forget" => (1u, ~[arg(param(ccx, 0u))], ty::mk_nil()), - ~"transmute" => (2, ~[ arg(param(ccx, 0)) ], param(ccx, 1)), + ~"forget" => (1u, ~[ param(ccx, 0) ], ty::mk_nil()), + ~"transmute" => (2, ~[ param(ccx, 0) ], param(ccx, 1)), ~"move_val" | ~"move_val_init" => { (1u, ~[ - arg(ty::mk_mut_rptr(tcx, - ty::re_bound(ty::br_anon(0)), - param(ccx, 0))), - arg(param(ccx, 0u)) + ty::mk_mut_rptr(tcx, ty::re_bound(ty::br_anon(0)), param(ccx, 0)), + param(ccx, 0u) ], ty::mk_nil()) } @@ -3483,30 +3471,26 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) { ~"atomic_cxchg" | ~"atomic_cxchg_acq"| ~"atomic_cxchg_rel" => { (0, ~[ - arg(ty::mk_mut_rptr(tcx, - ty::re_bound(ty::br_anon(0)), - ty::mk_int())), - arg(ty::mk_int()), - arg(ty::mk_int()) + ty::mk_mut_rptr(tcx, + ty::re_bound(ty::br_anon(0)), + ty::mk_int()), + ty::mk_int(), + ty::mk_int() ], ty::mk_int()) } ~"atomic_load" | ~"atomic_load_acq" => { (0, ~[ - arg(ty::mk_imm_rptr(tcx, - ty::re_bound(ty::br_anon(0)), - ty::mk_int())) + ty::mk_imm_rptr(tcx, ty::re_bound(ty::br_anon(0)), ty::mk_int()) ], ty::mk_int()) } ~"atomic_store" | ~"atomic_store_rel" => { (0, ~[ - arg(ty::mk_mut_rptr(tcx, - ty::re_bound(ty::br_anon(0)), - ty::mk_int())), - arg(ty::mk_int()) + ty::mk_mut_rptr(tcx, ty::re_bound(ty::br_anon(0)), ty::mk_int()), + ty::mk_int() ], ty::mk_nil()) } @@ -3515,10 +3499,8 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) { ~"atomic_xchg_rel" | ~"atomic_xadd_rel" | ~"atomic_xsub_rel" => { (0, ~[ - arg(ty::mk_mut_rptr(tcx, - ty::re_bound(ty::br_anon(0)), - ty::mk_int())), - arg(ty::mk_int()) + ty::mk_mut_rptr(tcx, ty::re_bound(ty::br_anon(0)), ty::mk_int()), + ty::mk_int() ], ty::mk_int()) } @@ -3536,7 +3518,7 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) { ty: tydesc_ty, mutbl: ast::m_imm }); - (0, ~[ arg(td_ptr), arg(visitor_object_ty) ], ty::mk_nil()) + (0, ~[ td_ptr, visitor_object_ty ], ty::mk_nil()) } ~"frame_address" => { let fty = ty::mk_closure(ccx.tcx, ty::ClosureTy { @@ -3546,16 +3528,11 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) { region: ty::re_bound(ty::br_anon(0)), sig: ty::FnSig { bound_lifetime_names: opt_vec::Empty, - inputs: ~[ - arg { - ty: ty::mk_imm_ptr(ccx.tcx, - ty::mk_mach_uint(ast::ty_u8)) - } - ], + inputs: ~[ty::mk_imm_ptr(ccx.tcx, ty::mk_mach_uint(ast::ty_u8))], output: ty::mk_nil() } }); - (0u, ~[ arg(fty) ], ty::mk_nil()) + (0u, ~[fty], ty::mk_nil()) } ~"morestack_addr" => { (0u, ~[], ty::mk_nil_ptr(ccx.tcx)) @@ -3563,101 +3540,102 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) { ~"memmove32" => { (0, ~[ - arg(ty::mk_ptr(tcx, ty::mt { + ty::mk_ptr(tcx, ty::mt { ty: ty::mk_u8(), mutbl: ast::m_mutbl - })), - arg(ty::mk_ptr(tcx, ty::mt { + }), + ty::mk_ptr(tcx, ty::mt { ty: ty::mk_u8(), mutbl: ast::m_imm - })), - arg(ty::mk_u32()) + }), + ty::mk_u32() ], ty::mk_nil()) } ~"memmove64" => { (0, - ~[arg(ty::mk_ptr(tcx, ty::mt { - ty: ty::mk_u8(), - mutbl: ast::m_mutbl - })), - arg(ty::mk_ptr(tcx, ty::mt { - ty: ty::mk_u8(), - mutbl: ast::m_imm - })), - arg(ty::mk_u64()) + ~[ + ty::mk_ptr(tcx, ty::mt { + ty: ty::mk_u8(), + mutbl: ast::m_mutbl + }), + ty::mk_ptr(tcx, ty::mt { + ty: ty::mk_u8(), + mutbl: ast::m_imm + }), + ty::mk_u64() ], ty::mk_nil()) } - ~"sqrtf32" => (0, ~[ arg(ty::mk_f32()) ], ty::mk_f32()), - ~"sqrtf64" => (0, ~[ arg(ty::mk_f64()) ], ty::mk_f64()), + ~"sqrtf32" => (0, ~[ ty::mk_f32() ], ty::mk_f32()), + ~"sqrtf64" => (0, ~[ ty::mk_f64() ], ty::mk_f64()), ~"powif32" => { (0, - ~[ arg(ty::mk_f32()), arg(ty::mk_i32()) ], + ~[ ty::mk_f32(), ty::mk_i32() ], ty::mk_f32()) } ~"powif64" => { (0, - ~[ arg(ty::mk_f64()), arg(ty::mk_i32()) ], + ~[ ty::mk_f64(), ty::mk_i32() ], ty::mk_f64()) } - ~"sinf32" => (0, ~[ arg(ty::mk_f32()) ], ty::mk_f32()), - ~"sinf64" => (0, ~[ arg(ty::mk_f64()) ], ty::mk_f64()), - ~"cosf32" => (0, ~[ arg(ty::mk_f32()) ], ty::mk_f32()), - ~"cosf64" => (0, ~[ arg(ty::mk_f64()) ], ty::mk_f64()), + ~"sinf32" => (0, ~[ ty::mk_f32() ], ty::mk_f32()), + ~"sinf64" => (0, ~[ ty::mk_f64() ], ty::mk_f64()), + ~"cosf32" => (0, ~[ ty::mk_f32() ], ty::mk_f32()), + ~"cosf64" => (0, ~[ ty::mk_f64() ], ty::mk_f64()), ~"powf32" => { (0, - ~[ arg(ty::mk_f32()), arg(ty::mk_f32()) ], + ~[ ty::mk_f32(), ty::mk_f32() ], ty::mk_f32()) } ~"powf64" => { (0, - ~[ arg(ty::mk_f64()), arg(ty::mk_f64()) ], + ~[ ty::mk_f64(), ty::mk_f64() ], ty::mk_f64()) } - ~"expf32" => (0, ~[ arg(ty::mk_f32()) ], ty::mk_f32()), - ~"expf64" => (0, ~[ arg(ty::mk_f64()) ], ty::mk_f64()), - ~"exp2f32" => (0, ~[ arg(ty::mk_f32()) ], ty::mk_f32()), - ~"exp2f64" => (0, ~[ arg(ty::mk_f64()) ], ty::mk_f64()), - ~"logf32" => (0, ~[ arg(ty::mk_f32()) ], ty::mk_f32()), - ~"logf64" => (0, ~[ arg(ty::mk_f64()) ], ty::mk_f64()), - ~"log10f32" => (0, ~[ arg(ty::mk_f32()) ], ty::mk_f32()), - ~"log10f64" => (0, ~[ arg(ty::mk_f64()) ], ty::mk_f64()), - ~"log2f32" => (0, ~[ arg(ty::mk_f32()) ], ty::mk_f32()), - ~"log2f64" => (0, ~[ arg(ty::mk_f64()) ], ty::mk_f64()), + ~"expf32" => (0, ~[ ty::mk_f32() ], ty::mk_f32()), + ~"expf64" => (0, ~[ ty::mk_f64() ], ty::mk_f64()), + ~"exp2f32" => (0, ~[ ty::mk_f32() ], ty::mk_f32()), + ~"exp2f64" => (0, ~[ ty::mk_f64() ], ty::mk_f64()), + ~"logf32" => (0, ~[ ty::mk_f32() ], ty::mk_f32()), + ~"logf64" => (0, ~[ ty::mk_f64() ], ty::mk_f64()), + ~"log10f32" => (0, ~[ ty::mk_f32() ], ty::mk_f32()), + ~"log10f64" => (0, ~[ ty::mk_f64() ], ty::mk_f64()), + ~"log2f32" => (0, ~[ ty::mk_f32() ], ty::mk_f32()), + ~"log2f64" => (0, ~[ ty::mk_f64() ], ty::mk_f64()), ~"fmaf32" => { (0, - ~[ arg(ty::mk_f32()), arg(ty::mk_f32()), arg(ty::mk_f32()) ], + ~[ ty::mk_f32(), ty::mk_f32(), ty::mk_f32() ], ty::mk_f32()) } ~"fmaf64" => { (0, - ~[ arg(ty::mk_f64()), arg(ty::mk_f64()), arg(ty::mk_f64()) ], + ~[ ty::mk_f64(), ty::mk_f64(), ty::mk_f64() ], ty::mk_f64()) } - ~"fabsf32" => (0, ~[ arg(ty::mk_f32()) ], ty::mk_f32()), - ~"fabsf64" => (0, ~[ arg(ty::mk_f64()) ], ty::mk_f64()), - ~"floorf32" => (0, ~[ arg(ty::mk_f32()) ], ty::mk_f32()), - ~"floorf64" => (0, ~[ arg(ty::mk_f64()) ], ty::mk_f64()), - ~"ceilf32" => (0, ~[ arg(ty::mk_f32()) ], ty::mk_f32()), - ~"ceilf64" => (0, ~[ arg(ty::mk_f64()) ], ty::mk_f64()), - ~"truncf32" => (0, ~[ arg(ty::mk_f32()) ], ty::mk_f32()), - ~"truncf64" => (0, ~[ arg(ty::mk_f64()) ], ty::mk_f64()), - ~"ctpop8" => (0, ~[ arg(ty::mk_i8()) ], ty::mk_i8()), - ~"ctpop16" => (0, ~[ arg(ty::mk_i16()) ], ty::mk_i16()), - ~"ctpop32" => (0, ~[ arg(ty::mk_i32()) ], ty::mk_i32()), - ~"ctpop64" => (0, ~[ arg(ty::mk_i64()) ], ty::mk_i64()), - ~"ctlz8" => (0, ~[ arg(ty::mk_i8()) ], ty::mk_i8()), - ~"ctlz16" => (0, ~[ arg(ty::mk_i16()) ], ty::mk_i16()), - ~"ctlz32" => (0, ~[ arg(ty::mk_i32()) ], ty::mk_i32()), - ~"ctlz64" => (0, ~[ arg(ty::mk_i64()) ], ty::mk_i64()), - ~"cttz8" => (0, ~[ arg(ty::mk_i8()) ], ty::mk_i8()), - ~"cttz16" => (0, ~[ arg(ty::mk_i16()) ], ty::mk_i16()), - ~"cttz32" => (0, ~[ arg(ty::mk_i32()) ], ty::mk_i32()), - ~"cttz64" => (0, ~[ arg(ty::mk_i64()) ], ty::mk_i64()), - ~"bswap16" => (0, ~[ arg(ty::mk_i16()) ], ty::mk_i16()), - ~"bswap32" => (0, ~[ arg(ty::mk_i32()) ], ty::mk_i32()), - ~"bswap64" => (0, ~[ arg(ty::mk_i64()) ], ty::mk_i64()), + ~"fabsf32" => (0, ~[ ty::mk_f32() ], ty::mk_f32()), + ~"fabsf64" => (0, ~[ ty::mk_f64() ], ty::mk_f64()), + ~"floorf32" => (0, ~[ ty::mk_f32() ], ty::mk_f32()), + ~"floorf64" => (0, ~[ ty::mk_f64() ], ty::mk_f64()), + ~"ceilf32" => (0, ~[ ty::mk_f32() ], ty::mk_f32()), + ~"ceilf64" => (0, ~[ ty::mk_f64() ], ty::mk_f64()), + ~"truncf32" => (0, ~[ ty::mk_f32() ], ty::mk_f32()), + ~"truncf64" => (0, ~[ ty::mk_f64() ], ty::mk_f64()), + ~"ctpop8" => (0, ~[ ty::mk_i8() ], ty::mk_i8()), + ~"ctpop16" => (0, ~[ ty::mk_i16() ], ty::mk_i16()), + ~"ctpop32" => (0, ~[ ty::mk_i32() ], ty::mk_i32()), + ~"ctpop64" => (0, ~[ ty::mk_i64() ], ty::mk_i64()), + ~"ctlz8" => (0, ~[ ty::mk_i8() ], ty::mk_i8()), + ~"ctlz16" => (0, ~[ ty::mk_i16() ], ty::mk_i16()), + ~"ctlz32" => (0, ~[ ty::mk_i32() ], ty::mk_i32()), + ~"ctlz64" => (0, ~[ ty::mk_i64() ], ty::mk_i64()), + ~"cttz8" => (0, ~[ ty::mk_i8() ], ty::mk_i8()), + ~"cttz16" => (0, ~[ ty::mk_i16() ], ty::mk_i16()), + ~"cttz32" => (0, ~[ ty::mk_i32() ], ty::mk_i32()), + ~"cttz64" => (0, ~[ ty::mk_i64() ], ty::mk_i64()), + ~"bswap16" => (0, ~[ ty::mk_i16() ], ty::mk_i16()), + ~"bswap32" => (0, ~[ ty::mk_i32() ], ty::mk_i32()), + ~"bswap64" => (0, ~[ ty::mk_i64() ], ty::mk_i64()), ref other => { tcx.sess.span_err(it.span, ~"unrecognized intrinsic function: `" + diff --git a/src/librustc/middle/typeck/check/regionmanip.rs b/src/librustc/middle/typeck/check/regionmanip.rs index cfbd012b7b7..87b105e3c7d 100644 --- a/src/librustc/middle/typeck/check/regionmanip.rs +++ b/src/librustc/middle/typeck/check/regionmanip.rs @@ -258,7 +258,7 @@ pub fn relate_free_regions( let mut all_tys = ~[]; for fn_sig.inputs.each |arg| { - all_tys.push(arg.ty); + all_tys.push(*arg); } for self_ty.each |&t| { all_tys.push(t); diff --git a/src/librustc/middle/typeck/check/writeback.rs b/src/librustc/middle/typeck/check/writeback.rs index 2869c3737c9..394d00bef2d 100644 --- a/src/librustc/middle/typeck/check/writeback.rs +++ b/src/librustc/middle/typeck/check/writeback.rs @@ -13,7 +13,6 @@ // substitutions. use middle::pat_util; -use middle::ty::arg; use middle::ty; use middle::typeck::check::{FnCtxt, SelfInfo}; use middle::typeck::infer::{force_all, resolve_all, resolve_region}; @@ -63,14 +62,9 @@ fn resolve_method_map_entry(fcx: @mut FnCtxt, sp: span, id: ast::node_id) { match fcx.inh.method_map.find(&id) { None => {} Some(mme) => { - for resolve_type_vars_in_type(fcx, sp, mme.self_arg.ty).each |t| { + for resolve_type_vars_in_type(fcx, sp, mme.self_ty).each |t| { let method_map = fcx.ccx.method_map; - let new_entry = method_map_entry { - self_arg: arg { - ty: *t - }, - ..*mme - }; + let new_entry = method_map_entry { self_ty: *t, ..*mme }; debug!("writeback::resolve_method_map_entry(id=%?, \ new_entry=%?)", id, new_entry); diff --git a/src/librustc/middle/typeck/coherence.rs b/src/librustc/middle/typeck/coherence.rs index 17103806d1e..c64a0235eb1 100644 --- a/src/librustc/middle/typeck/coherence.rs +++ b/src/librustc/middle/typeck/coherence.rs @@ -156,7 +156,7 @@ pub fn method_to_MethodInfo(ast_method: @method) -> @MethodInfo { did: local_def(ast_method.id), n_tps: ast_method.generics.ty_params.len(), ident: ast_method.ident, - self_type: ast_method.self_ty.node + explicit_self: ast_method.explicit_self.node } } @@ -383,7 +383,7 @@ pub impl CoherenceChecker { did: new_did, n_tps: trait_method.generics.type_param_defs.len(), ident: trait_method.ident, - self_type: trait_method.self_ty + explicit_self: trait_method.explicit_self }, trait_method_def_id: trait_method.def_id }; @@ -527,7 +527,7 @@ pub impl CoherenceChecker { #[cfg(stage0)] fn each_provided_trait_method(&self, trait_did: ast::def_id, - f: &fn(x: @ty::method) -> bool) { + f: &fn(@ty::Method) -> bool) { // Make a list of all the names of the provided methods. // XXX: This is horrible. let mut provided_method_idents = HashSet::new(); @@ -547,7 +547,7 @@ pub impl CoherenceChecker { #[cfg(not(stage0))] fn each_provided_trait_method(&self, trait_did: ast::def_id, - f: &fn(x: @ty::method) -> bool) -> bool { + f: &fn(x: @ty::Method) -> bool) -> bool { // Make a list of all the names of the provided methods. // XXX: This is horrible. let mut provided_method_idents = HashSet::new(); @@ -975,7 +975,7 @@ pub impl CoherenceChecker { did: new_did, n_tps: trait_method_info.ty.generics.type_param_defs.len(), ident: trait_method_info.ty.ident, - self_type: trait_method_info.ty.self_ty + explicit_self: trait_method_info.ty.explicit_self }, trait_method_def_id: trait_method_info.def_id }; @@ -1073,7 +1073,7 @@ fn subst_receiver_types_in_method_ty( impl_id: ast::node_id, trait_ref: &ty::TraitRef, new_def_id: ast::def_id, - method: &ty::method) -> ty::method + method: &ty::Method) -> ty::Method { /*! * Substitutes the values for the receiver's type parameters @@ -1117,19 +1117,22 @@ fn subst_receiver_types_in_method_ty( tps: combined_tps }; - ty::method { - ident: method.ident, + ty::Method::new( + method.ident, + + // method types *can* appear in the generic bounds + method.generics.subst(tcx, &combined_substs), // method tps cannot appear in the self_ty, so use `substs` from trait ref - transformed_self_ty: method.transformed_self_ty.subst(tcx, &trait_ref.substs), - - // method types *can* appear in the generic bounds or the fty - generics: method.generics.subst(tcx, &combined_substs), - fty: method.fty.subst(tcx, &combined_substs), - self_ty: method.self_ty, - vis: method.vis, - def_id: new_def_id - } + method.transformed_self_ty.subst(tcx, &trait_ref.substs), + + // method types *can* appear in the fty + method.fty.subst(tcx, &combined_substs), + + method.explicit_self, + method.vis, + new_def_id + ) } pub fn check_coherence(crate_context: @mut CrateCtxt, crate: @crate) { diff --git a/src/librustc/middle/typeck/collect.rs b/src/librustc/middle/typeck/collect.rs index dd432352432..4773e637c35 100644 --- a/src/librustc/middle/typeck/collect.rs +++ b/src/librustc/middle/typeck/collect.rs @@ -52,7 +52,7 @@ use syntax::ast_map; use syntax::ast_util::{local_def, split_trait_methods}; use syntax::codemap::span; use syntax::codemap; -use syntax::print::pprust::{path_to_str, self_ty_to_str}; +use syntax::print::pprust::{path_to_str, explicit_self_to_str}; use syntax::visit; use syntax::opt_vec::OptVec; use syntax::opt_vec; @@ -227,26 +227,26 @@ pub fn ensure_trait_methods(ccx: &CrateCtxt, }, _) => { let trait_ty_generics = ty_generics(ccx, region_paramd, generics, 0); - // For each method, construct a suitable ty::method and + // For each method, construct a suitable ty::Method and // store it into the `tcx.methods` table: for ms.each |m| { let ty_method = @match m { &ast::required(ref m) => { ty_method_of_trait_method( ccx, trait_id, region_paramd, generics, - &m.id, &m.ident, &m.self_ty, + &m.id, &m.ident, &m.explicit_self, &m.generics, &m.purity, &m.decl) } &ast::provided(ref m) => { ty_method_of_trait_method( ccx, trait_id, region_paramd, generics, - &m.id, &m.ident, &m.self_ty, + &m.id, &m.ident, &m.explicit_self, &m.generics, &m.purity, &m.decl) } }; - if ty_method.self_ty == ast::sty_static { + if ty_method.explicit_self == ast::sty_static { make_static_method_ty(ccx, trait_id, ty_method, &trait_ty_generics); } @@ -270,7 +270,7 @@ pub fn ensure_trait_methods(ccx: &CrateCtxt, fn make_static_method_ty(ccx: &CrateCtxt, trait_id: ast::node_id, - m: &ty::method, + m: &ty::Method, trait_ty_generics: &ty::Generics) { // If declaration is // @@ -376,27 +376,27 @@ pub fn ensure_trait_methods(ccx: &CrateCtxt, trait_generics: &ast::Generics, m_id: &ast::node_id, m_ident: &ast::ident, - m_self_ty: &ast::self_ty, + m_explicit_self: &ast::explicit_self, m_generics: &ast::Generics, m_purity: &ast::purity, - m_decl: &ast::fn_decl) -> ty::method + m_decl: &ast::fn_decl) -> ty::Method { let trait_self_ty = ty::mk_self(this.tcx, local_def(trait_id)); - let rscope = MethodRscope::new(m_self_ty.node, trait_rp, trait_generics); + let rscope = MethodRscope::new(m_explicit_self.node, trait_rp, trait_generics); let (transformed_self_ty, fty) = astconv::ty_of_method(this, &rscope, *m_purity, &m_generics.lifetimes, - trait_self_ty, *m_self_ty, m_decl); + trait_self_ty, *m_explicit_self, m_decl); let num_trait_type_params = trait_generics.ty_params.len(); - ty::method { - ident: *m_ident, - generics: ty_generics(this, None, m_generics, num_trait_type_params), - transformed_self_ty: transformed_self_ty, - fty: fty, - self_ty: m_self_ty.node, + ty::Method::new( + *m_ident, + ty_generics(this, None, m_generics, num_trait_type_params), + transformed_self_ty, + fty, + m_explicit_self.node, // assume public, because this is only invoked on trait methods - vis: ast::public, - def_id: local_def(*m_id) - } + ast::public, + local_def(*m_id) + ) } } @@ -444,7 +444,7 @@ pub fn ensure_supertraits(ccx: &CrateCtxt, pub fn compare_impl_method(tcx: ty::ctxt, impl_tps: uint, cm: &ConvertedMethod, - trait_m: &ty::method, + trait_m: &ty::Method, trait_substs: &ty::substs, self_ty: ty::t) { debug!("compare_impl_method()"); @@ -459,7 +459,7 @@ pub fn compare_impl_method(tcx: ty::ctxt, // that the error messages you get out of this code are a bit more // inscrutable, particularly for cases where one method has no // self. - match (&trait_m.self_ty, &impl_m.self_ty) { + match (&trait_m.explicit_self, &impl_m.explicit_self) { (&ast::sty_static, &ast::sty_static) => {} (&ast::sty_static, _) => { tcx.sess.span_err( @@ -467,7 +467,7 @@ pub fn compare_impl_method(tcx: ty::ctxt, fmt!("method `%s` has a `%s` declaration in the impl, \ but not in the trait", *tcx.sess.str_of(trait_m.ident), - self_ty_to_str(impl_m.self_ty, tcx.sess.intr()))); + explicit_self_to_str(impl_m.explicit_self, tcx.sess.intr()))); return; } (_, &ast::sty_static) => { @@ -476,7 +476,7 @@ pub fn compare_impl_method(tcx: ty::ctxt, fmt!("method `%s` has a `%s` declaration in the trait, \ but not in the impl", *tcx.sess.str_of(trait_m.ident), - self_ty_to_str(trait_m.self_ty, tcx.sess.intr()))); + explicit_self_to_str(trait_m.explicit_self, tcx.sess.intr()))); return; } _ => { @@ -499,15 +499,15 @@ pub fn compare_impl_method(tcx: ty::ctxt, return; } - if vec::len(impl_m.fty.sig.inputs) != vec::len(trait_m.fty.sig.inputs) { + if impl_m.fty.sig.inputs.len() != trait_m.fty.sig.inputs.len() { tcx.sess.span_err( cm.span, fmt!("method `%s` has %u parameter%s \ but the trait has %u", *tcx.sess.str_of(trait_m.ident), - vec::len(impl_m.fty.sig.inputs), - if vec::len(impl_m.fty.sig.inputs) == 1 { "" } else { "s" }, - vec::len(trait_m.fty.sig.inputs))); + impl_m.fty.sig.inputs.len(), + if impl_m.fty.sig.inputs.len() == 1 { "" } else { "s" }, + trait_m.fty.sig.inputs.len())); return; } @@ -576,14 +576,10 @@ pub fn compare_impl_method(tcx: ty::ctxt, // represent the self argument (unless this is a static method). // This argument will have the *transformed* self type. for trait_m.transformed_self_ty.each |&t| { - trait_fn_args.push(ty::arg { - ty: t - }); + trait_fn_args.push(t); } for impl_m.transformed_self_ty.each |&t| { - impl_fn_args.push(ty::arg { - ty: t - }); + impl_fn_args.push(t); } // Add in the normal arguments. @@ -727,7 +723,7 @@ pub fn convert_field(ccx: &CrateCtxt, } pub struct ConvertedMethod { - mty: @ty::method, + mty: @ty::Method, id: ast::node_id, span: span, body_id: ast::node_id @@ -780,16 +776,16 @@ pub fn convert_methods(ccx: &CrateCtxt, untransformed_rcvr_ty: ty::t, rcvr_generics: &ast::Generics, rcvr_visibility: ast::visibility, - method_generics: &ast::Generics) -> ty::method + method_generics: &ast::Generics) -> ty::Method { - let rscope = MethodRscope::new(m.self_ty.node, + let rscope = MethodRscope::new(m.explicit_self.node, rp, rcvr_generics); let (transformed_self_ty, fty) = astconv::ty_of_method(ccx, &rscope, m.purity, &method_generics.lifetimes, untransformed_rcvr_ty, - m.self_ty, &m.decl); + m.explicit_self, &m.decl); // if the method specifies a visibility, use that, otherwise // inherit the visibility from the impl (so `foo` in `pub impl @@ -798,15 +794,15 @@ pub fn convert_methods(ccx: &CrateCtxt, let method_vis = m.vis.inherit_from(rcvr_visibility); let num_rcvr_type_params = rcvr_generics.ty_params.len(); - ty::method { - ident: m.ident, - generics: ty_generics(ccx, None, &m.generics, num_rcvr_type_params), - transformed_self_ty: transformed_self_ty, - fty: fty, - self_ty: m.self_ty.node, - vis: method_vis, - def_id: local_def(m.id) - } + ty::Method::new( + m.ident, + ty_generics(ccx, None, &m.generics, num_rcvr_type_params), + transformed_self_ty, + fty, + m.explicit_self.node, + method_vis, + local_def(m.id) + ) } } diff --git a/src/librustc/middle/typeck/infer/combine.rs b/src/librustc/middle/typeck/infer/combine.rs index a845d6fe9d0..fcd2c6ffe59 100644 --- a/src/librustc/middle/typeck/infer/combine.rs +++ b/src/librustc/middle/typeck/infer/combine.rs @@ -55,7 +55,7 @@ // now. use middle::ty::{FloatVar, FnSig, IntVar, TyVar}; -use middle::ty::{IntType, UintType, arg, substs}; +use middle::ty::{IntType, UintType, substs}; use middle::ty; use middle::typeck::infer::glb::Glb; use middle::typeck::infer::lub::Lub; @@ -95,7 +95,7 @@ pub trait Combine { b: &ty::ClosureTy) -> cres<ty::ClosureTy>; fn fn_sigs(&self, a: &ty::FnSig, b: &ty::FnSig) -> cres<ty::FnSig>; fn flds(&self, a: ty::field, b: ty::field) -> cres<ty::field>; - fn args(&self, a: ty::arg, b: ty::arg) -> cres<ty::arg>; + fn args(&self, a: ty::t, b: ty::t) -> cres<ty::t>; fn sigils(&self, p1: ast::Sigil, p2: ast::Sigil) -> cres<ast::Sigil>; fn purities(&self, a: purity, b: purity) -> cres<purity>; fn abis(&self, a: AbiSet, b: AbiSet) -> cres<AbiSet>; @@ -311,12 +311,9 @@ pub fn super_flds<C:Combine>( } } -pub fn super_args<C:Combine>(this: &C, a: ty::arg, b: ty::arg) - -> cres<ty::arg> { - do this.contratys(a.ty, b.ty).chain |t| { - Ok(arg { - ty: t - }) +pub fn super_args<C:Combine>(this: &C, a: ty::t, b: ty::t) -> cres<ty::t> { + do this.contratys(a, b).chain |t| { + Ok(t) } } @@ -407,10 +404,7 @@ pub fn super_bare_fn_tys<C:Combine>( pub fn super_fn_sigs<C:Combine>( this: &C, a_f: &ty::FnSig, b_f: &ty::FnSig) -> cres<ty::FnSig> { - fn argvecs<C:Combine>(this: &C, - a_args: &[ty::arg], - b_args: &[ty::arg]) -> cres<~[ty::arg]> - { + fn argvecs<C:Combine>(this: &C, a_args: &[ty::t], b_args: &[ty::t]) -> cres<~[ty::t]> { if vec::same_length(a_args, b_args) { map_vec2(a_args, b_args, |a, b| this.args(*a, *b)) } else { diff --git a/src/librustc/middle/typeck/infer/glb.rs b/src/librustc/middle/typeck/infer/glb.rs index 462d7a003f4..42e42ddb1e7 100644 --- a/src/librustc/middle/typeck/infer/glb.rs +++ b/src/librustc/middle/typeck/infer/glb.rs @@ -153,7 +153,7 @@ impl Combine for Glb { super_trait_stores(self, vk, a, b) } - fn args(&self, a: ty::arg, b: ty::arg) -> cres<ty::arg> { + fn args(&self, a: ty::t, b: ty::t) -> cres<ty::t> { super_args(self, a, b) } diff --git a/src/librustc/middle/typeck/infer/lub.rs b/src/librustc/middle/typeck/infer/lub.rs index bd5821873d2..20a051f0531 100644 --- a/src/librustc/middle/typeck/infer/lub.rs +++ b/src/librustc/middle/typeck/infer/lub.rs @@ -236,7 +236,7 @@ impl Combine for Lub { super_trait_stores(self, vk, a, b) } - fn args(&self, a: ty::arg, b: ty::arg) -> cres<ty::arg> { + fn args(&self, a: ty::t, b: ty::t) -> cres<ty::t> { super_args(self, a, b) } diff --git a/src/librustc/middle/typeck/infer/sub.rs b/src/librustc/middle/typeck/infer/sub.rs index 48d7765f88e..ca083bc2d86 100644 --- a/src/librustc/middle/typeck/infer/sub.rs +++ b/src/librustc/middle/typeck/infer/sub.rs @@ -245,7 +245,7 @@ impl Combine for Sub { super_trait_stores(self, vk, a, b) } - fn args(&self, a: ty::arg, b: ty::arg) -> cres<ty::arg> { + fn args(&self, a: ty::t, b: ty::t) -> cres<ty::t> { super_args(self, a, b) } diff --git a/src/librustc/middle/typeck/infer/to_str.rs b/src/librustc/middle/typeck/infer/to_str.rs index 779346c380c..d9088c06493 100644 --- a/src/librustc/middle/typeck/infer/to_str.rs +++ b/src/librustc/middle/typeck/infer/to_str.rs @@ -31,7 +31,7 @@ impl InferStr for ty::t { impl InferStr for FnSig { fn inf_str(&self, cx: &InferCtxt) -> ~str { fmt!("(%s) -> %s", - str::connect(self.inputs.map(|a| a.ty.inf_str(cx)), ", "), + str::connect(self.inputs.map(|a| a.inf_str(cx)), ", "), self.output.inf_str(cx)) } } diff --git a/src/librustc/middle/typeck/mod.rs b/src/librustc/middle/typeck/mod.rs index 5da14d99171..0dec0fc937b 100644 --- a/src/librustc/middle/typeck/mod.rs +++ b/src/librustc/middle/typeck/mod.rs @@ -118,13 +118,13 @@ pub struct method_param { pub struct method_map_entry { // the type of the self parameter, which is not reflected in the fn type // (FIXME #3446) - self_arg: ty::arg, + self_ty: ty::t, // the mode of `self` self_mode: ty::SelfMode, // the type of explicit self on the method - explicit_self: ast::self_ty_, + explicit_self: ast::explicit_self_, // method details being invoked origin: method_origin, @@ -310,7 +310,7 @@ fn check_main_fn_ty(ccx: @mut CrateCtxt, _ => () } let mut ok = ty::type_is_nil(fn_ty.sig.output); - let num_args = vec::len(fn_ty.sig.inputs); + let num_args = fn_ty.sig.inputs.len(); ok &= num_args == 0u; if !ok { tcx.sess.span_err( @@ -351,22 +351,15 @@ fn check_start_fn_ty(ccx: @mut CrateCtxt, _ => () } - fn arg(ty: ty::t) -> ty::arg { - ty::arg { - ty: ty - } - } - let se_ty = ty::mk_bare_fn(tcx, ty::BareFnTy { purity: ast::impure_fn, abis: abi::AbiSet::Rust(), sig: ty::FnSig { bound_lifetime_names: opt_vec::Empty, inputs: ~[ - arg(ty::mk_int()), - arg(ty::mk_imm_ptr(tcx, - ty::mk_imm_ptr(tcx, ty::mk_u8()))), - arg(ty::mk_imm_ptr(tcx, ty::mk_u8())) + ty::mk_int(), + ty::mk_imm_ptr(tcx, ty::mk_imm_ptr(tcx, ty::mk_u8())), + ty::mk_imm_ptr(tcx, ty::mk_u8()) ], output: ty::mk_int() } diff --git a/src/librustc/middle/typeck/rscope.rs b/src/librustc/middle/typeck/rscope.rs index f7bf5106fa6..7c37784b09d 100644 --- a/src/librustc/middle/typeck/rscope.rs +++ b/src/librustc/middle/typeck/rscope.rs @@ -142,7 +142,7 @@ impl RegionParameterization { } pub struct MethodRscope { - self_ty: ast::self_ty_, + explicit_self: ast::explicit_self_, variance: Option<ty::region_variance>, region_param_names: RegionParamNames, } @@ -150,14 +150,14 @@ pub struct MethodRscope { impl MethodRscope { // `generics` here refers to the generics of the outer item (impl or // trait). - pub fn new(self_ty: ast::self_ty_, + pub fn new(explicit_self: ast::explicit_self_, variance: Option<ty::region_variance>, rcvr_generics: &ast::Generics) -> MethodRscope { let region_param_names = RegionParamNames::from_generics(rcvr_generics); MethodRscope { - self_ty: self_ty, + explicit_self: explicit_self, variance: variance, region_param_names: region_param_names } diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index 804b23025f0..13a2f376c06 100644 --- a/src/librustc/util/ppaux.rs +++ b/src/librustc/util/ppaux.rs @@ -11,7 +11,7 @@ use metadata::encoder; use middle::ty::{ReSkolemized, ReVar}; use middle::ty::{bound_region, br_anon, br_named, br_self, br_cap_avoid}; -use middle::ty::{br_fresh, ctxt, field, method}; +use middle::ty::{br_fresh, ctxt, field}; use middle::ty::{mt, t, param_ty}; use middle::ty::{re_bound, re_free, re_scope, re_infer, re_static, Region, re_empty}; @@ -281,7 +281,7 @@ pub fn tys_to_str(cx: ctxt, ts: &[t]) -> ~str { pub fn fn_sig_to_str(cx: ctxt, typ: &ty::FnSig) -> ~str { fmt!("fn%s -> %s", - tys_to_str(cx, typ.inputs.map(|a| a.ty)), + tys_to_str(cx, typ.inputs.map(|a| *a)), ty_to_str(cx, typ.output)) } @@ -290,8 +290,8 @@ pub fn trait_ref_to_str(cx: ctxt, trait_ref: &ty::TraitRef) -> ~str { } pub fn ty_to_str(cx: ctxt, typ: t) -> ~str { - fn fn_input_to_str(cx: ctxt, input: ty::arg) -> ~str { - ty_to_str(cx, input.ty) + fn fn_input_to_str(cx: ctxt, input: ty::t) -> ~str { + ty_to_str(cx, input) } fn bare_fn_to_str(cx: ctxt, purity: ast::purity, @@ -375,7 +375,7 @@ pub fn ty_to_str(cx: ctxt, typ: t) -> ~str { } } } - fn method_to_str(cx: ctxt, m: method) -> ~str { + fn method_to_str(cx: ctxt, m: ty::Method) -> ~str { bare_fn_to_str(cx, m.fty.purity, m.fty.abis, @@ -470,7 +470,7 @@ pub fn parameterized(cx: ctxt, } }; - if vec::len(tps) > 0u { + if tps.len() > 0u { let strs = vec::map(tps, |t| ty_to_str(cx, *t)); fmt!("%s%s<%s>", base, r_str, str::connect(strs, ",")) } else { @@ -633,15 +633,15 @@ impl Repr for ty::Generics { } } -impl Repr for ty::method { +impl Repr for ty::Method { fn repr(&self, tcx: ctxt) -> ~str { fmt!("method {ident: %s, generics: %s, transformed_self_ty: %s, \ - fty: %s, self_ty: %s, vis: %s, def_id: %s}", + fty: %s, explicit_self: %s, vis: %s, def_id: %s}", self.ident.repr(tcx), self.generics.repr(tcx), self.transformed_self_ty.repr(tcx), self.fty.repr(tcx), - self.self_ty.repr(tcx), + self.explicit_self.repr(tcx), self.vis.repr(tcx), self.def_id.repr(tcx)) } @@ -653,7 +653,7 @@ impl Repr for ast::ident { } } -impl Repr for ast::self_ty_ { +impl Repr for ast::explicit_self_ { fn repr(&self, _tcx: ctxt) -> ~str { fmt!("%?", *self) } @@ -685,18 +685,12 @@ impl Repr for typeck::method_map_entry { fmt!("method_map_entry {self_arg: %s, \ explicit_self: %s, \ origin: %s}", - self.self_arg.repr(tcx), + self.self_ty.repr(tcx), self.explicit_self.repr(tcx), self.origin.repr(tcx)) } } -impl Repr for ty::arg { - fn repr(&self, tcx: ctxt) -> ~str { - fmt!("(%s)", self.ty.repr(tcx)) - } -} - impl Repr for typeck::method_origin { fn repr(&self, tcx: ctxt) -> ~str { match self { diff --git a/src/librustdoc/tystr_pass.rs b/src/librustdoc/tystr_pass.rs index bd6777df4af..12689466c8c 100644 --- a/src/librustdoc/tystr_pass.rs +++ b/src/librustdoc/tystr_pass.rs @@ -187,7 +187,7 @@ fn get_method_sig( &ty_m.decl, ty_m.purity, ty_m.ident, - Some(ty_m.self_ty.node), + Some(ty_m.explicit_self.node), &ty_m.generics, extract::interner() )) @@ -197,7 +197,7 @@ fn get_method_sig( &m.decl, m.purity, m.ident, - Some(m.self_ty.node), + Some(m.explicit_self.node), &m.generics, extract::interner() )) @@ -218,7 +218,7 @@ fn get_method_sig( &method.decl, method.purity, method.ident, - Some(method.self_ty.node), + Some(method.explicit_self.node), &method.generics, extract::interner() )) @@ -405,7 +405,7 @@ mod test { #[test] fn should_not_add_impl_trait_types_if_none() { let doc = mk_doc(~"impl int { fn a() { } }"); - assert!(vec::len(doc.cratemod().impls()[0].trait_types) == 0); + assert!(doc.cratemod().impls()[0].trait_types.len() == 0); } #[test] diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs index 062ad403dd6..07c1c226d1f 100644 --- a/src/libstd/ebml.rs +++ b/src/libstd/ebml.rs @@ -628,7 +628,6 @@ pub mod writer { use core::io; use core::str; - use core::vec; // ebml writing pub struct Encoder { @@ -707,7 +706,7 @@ pub mod writer { fn wr_tagged_bytes(&mut self, tag_id: uint, b: &[u8]) { write_vuint(self.writer, tag_id); - write_vuint(self.writer, vec::len(b)); + write_vuint(self.writer, b.len()); self.writer.write(b); } @@ -760,7 +759,7 @@ pub mod writer { } fn wr_bytes(&mut self, b: &[u8]) { - debug!("Write %u bytes", vec::len(b)); + debug!("Write %u bytes", b.len()); self.writer.write(b); } diff --git a/src/libstd/fun_treemap.rs b/src/libstd/fun_treemap.rs index 3bffeddbe09..6b051fa21b1 100644 --- a/src/libstd/fun_treemap.rs +++ b/src/libstd/fun_treemap.rs @@ -33,45 +33,40 @@ enum TreeNode<K, V> { pub fn init<K, V>() -> Treemap<K, V> { @Empty } /// Insert a value into the map -pub fn insert<K:Copy + Eq + Ord,V:Copy>(m: Treemap<K, V>, k: K, v: V) - -> Treemap<K, V> { +pub fn insert<K:Copy + Eq + Ord,V:Copy>(m: Treemap<K, V>, k: K, v: V) -> Treemap<K, V> { @match m { - @Empty => Node(@k, @v, @Empty, @Empty), - @Node(@copy kk, vv, left, right) => { - if k < kk { - Node(@kk, vv, insert(left, k, v), right) - } else if k == kk { - Node(@kk, @v, left, right) - } else { Node(@kk, vv, left, insert(right, k, v)) } - } - } + @Empty => Node(@k, @v, @Empty, @Empty), + @Node(@copy kk, vv, left, right) => cond!( + (k < kk) { Node(@kk, vv, insert(left, k, v), right) } + (k == kk) { Node(@kk, @v, left, right) } + _ { Node(@kk, vv, left, insert(right, k, v)) } + ) + } } /// Find a value based on the key pub fn find<K:Eq + Ord,V:Copy>(m: Treemap<K, V>, k: K) -> Option<V> { match *m { - Empty => None, - Node(@ref kk, @copy v, left, right) => { - if k == *kk { - Some(v) - } else if k < *kk { find(left, k) } else { find(right, k) } - } + Empty => None, + Node(@ref kk, @copy v, left, right) => cond!( + (k == *kk) { Some(v) } + (k < *kk) { find(left, k) } + _ { find(right, k) } + ) } } /// Visit all pairs in the map in order. pub fn traverse<K, V: Copy>(m: Treemap<K, V>, f: &fn(&K, &V)) { match *m { - Empty => (), - /* - Previously, this had what looked like redundant - matches to me, so I changed it. but that may be a - de-optimization -- tjc - */ - Node(@ref k, @ref v, left, right) => { - traverse(left, f); - f(k, v); - traverse(right, f); - } + Empty => (), + // Previously, this had what looked like redundant + // matches to me, so I changed it. but that may be a + // de-optimization -- tjc + Node(@ref k, @ref v, left, right) => { + traverse(left, f); + f(k, v); + traverse(right, f); + } } } diff --git a/src/libstd/md4.rs b/src/libstd/md4.rs index 71b62ca36a5..84561256cd1 100644 --- a/src/libstd/md4.rs +++ b/src/libstd/md4.rs @@ -23,7 +23,7 @@ pub fn md4(msg: &[u8]) -> Quad { // subtle: if orig_len is merely uint, then the code below // which performs shifts by 32 bits or more has undefined // results. - let orig_len: u64 = (vec::len(msg) * 8u) as u64; + let orig_len: u64 = (msg.len() * 8u) as u64; // pad message let mut msg = vec::append(vec::to_owned(msg), ~[0x80u8]); @@ -51,7 +51,7 @@ pub fn md4(msg: &[u8]) -> Quad { } let mut i = 0u; - let e = vec::len(msg); + let e = msg.len(); let mut x = vec::from_elem(16u, 0u32); while i < e { let aa = a, bb = b, cc = c, dd = d; diff --git a/src/libstd/net_ip.rs b/src/libstd/net_ip.rs index f928f10b5fc..cc4e7ee0204 100644 --- a/src/libstd/net_ip.rs +++ b/src/libstd/net_ip.rs @@ -15,7 +15,6 @@ use core::comm::{stream, SharedChan}; use core::ptr; use core::result; use core::str; -use core::vec; use iotask = uv::iotask::IoTask; use interact = uv::iotask::interact; @@ -340,7 +339,7 @@ extern fn get_addr_cb(handle: *uv_getaddrinfo_t, } } debug!("successful process addrinfo result, len: %?", - vec::len(out_vec)); + out_vec.len()); output_ch.send(result::Ok(out_vec)); } else { @@ -424,7 +423,7 @@ mod test { // this.. mostly just wanting to see it work, atm. let results = result::unwrap(ga_result); debug!("test_get_addr: Number of results for %s: %?", - localhost_name, vec::len(results)); + localhost_name, results.len()); for results.each |r| { let ipv_prefix = match *r { Ipv4(_) => ~"IPv4", diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs index 9387903d842..37578e42baf 100644 --- a/src/libstd/net_tcp.rs +++ b/src/libstd/net_tcp.rs @@ -1802,7 +1802,7 @@ mod test { debug!("BUF_WRITE: val len %?", str::len(val)); do str::byte_slice(val) |b_slice| { debug!("BUF_WRITE: b_slice len %?", - vec::len(b_slice)); + b_slice.len()); w.write(b_slice) } } @@ -1810,7 +1810,7 @@ mod test { fn buf_read<R:io::Reader>(r: &R, len: uint) -> ~str { let new_bytes = (*r).read_bytes(len); debug!("in buf_read.. new_bytes len: %?", - vec::len(new_bytes)); + new_bytes.len()); str::from_bytes(new_bytes) } @@ -1863,7 +1863,7 @@ mod test { result::Ok(data) => { debug!("SERVER: got REQ str::from_bytes.."); debug!("SERVER: REQ data len: %?", - vec::len(data)); + data.len()); server_ch.send( str::from_bytes(data)); debug!("SERVER: before write"); diff --git a/src/libstd/par.rs b/src/libstd/par.rs index cf0eba9d30c..d1af484cb22 100644 --- a/src/libstd/par.rs +++ b/src/libstd/par.rs @@ -58,9 +58,8 @@ fn map_slices<A:Copy + Owned,B:Copy + Owned>( info!("pre-slice: %?", (base, slice)); let slice : &[A] = cast::transmute(slice); - info!("slice: %?", - (base, vec::len(slice), end - base)); - assert!((vec::len(slice) == end - base)); + info!("slice: %?", (base, slice.len(), end - base)); + assert!(slice.len() == end - base); f(base, slice) } }; diff --git a/src/libstd/rope.rs b/src/libstd/rope.rs index 2fa12809db6..9afa7262ce4 100644 --- a/src/libstd/rope.rs +++ b/src/libstd/rope.rs @@ -164,7 +164,7 @@ pub fn append_rope(left: Rope, right: Rope) -> Rope { */ pub fn concat(v: ~[Rope]) -> Rope { //Copy `v` into a mut vector - let mut len = vec::len(v); + let mut len = v.len(); if len == 0u { return node::Empty; } let mut ropes = vec::from_elem(len, v[0]); for uint::range(1u, len) |i| { @@ -770,7 +770,7 @@ pub mod node { */ pub fn tree_from_forest_destructive(forest: &mut [@Node]) -> @Node { let mut i; - let mut len = vec::len(forest); + let mut len = forest.len(); while len > 1u { i = 0u; while i < len - 1u {//Concat nodes 0 with 1, 2 with 3 etc. diff --git a/src/libstd/sha1.rs b/src/libstd/sha1.rs index 4b410ebfdd2..6d8bf20d837 100644 --- a/src/libstd/sha1.rs +++ b/src/libstd/sha1.rs @@ -90,8 +90,8 @@ pub fn sha1() -> @Sha1 { } } fn process_msg_block(st: &mut Sha1State) { - assert!((vec::len(st.h) == digest_buf_len)); - assert!((vec::uniq_len(st.work_buf) == work_buf_len)); + assert!(st.h.len() == digest_buf_len); + assert!(vec::uniq_len(st.work_buf) == work_buf_len); let mut t: int; // Loop counter let w = st.work_buf; @@ -230,7 +230,7 @@ pub fn sha1() -> @Sha1 { impl Sha1 for Sha1State { fn reset(&mut self) { - assert!((vec::len(self.h) == digest_buf_len)); + assert!(self.h.len() == digest_buf_len); self.len_low = 0u32; self.len_high = 0u32; self.msg_block_idx = 0u; diff --git a/src/libstd/std.rc b/src/libstd/std.rc index 915aab59a71..d29791449b6 100644 --- a/src/libstd/std.rc +++ b/src/libstd/std.rc @@ -63,6 +63,7 @@ pub mod flatpipes; pub mod bitv; pub mod deque; +#[cfg(not(stage0))] pub mod fun_treemap; pub mod list; pub mod priority_queue; diff --git a/src/libstd/sync.rs b/src/libstd/sync.rs index 59c6a804408..449edacad32 100644 --- a/src/libstd/sync.rs +++ b/src/libstd/sync.rs @@ -19,7 +19,6 @@ use core::unstable::sync::{Exclusive, exclusive}; use core::ptr; use core::task; use core::util; -use core::vec; /**************************************************************************** * Internals @@ -220,7 +219,7 @@ pub impl<'self> Condvar<'self> { do task::unkillable { // Release lock, 'atomically' enqueuing ourselves in so doing. do (**self.sem).with |state| { - if condvar_id < vec::len(state.blocked) { + if condvar_id < state.blocked.len() { // Drop the lock. state.count += 1; if state.count <= 0 { @@ -230,7 +229,7 @@ pub impl<'self> Condvar<'self> { let SignalEnd = SignalEnd.swap_unwrap(); state.blocked[condvar_id].tail.send(SignalEnd); } else { - out_of_bounds = Some(vec::len(state.blocked)); + out_of_bounds = Some(state.blocked.len()); } } @@ -285,10 +284,10 @@ pub impl<'self> Condvar<'self> { let mut out_of_bounds = None; let mut result = false; do (**self.sem).with |state| { - if condvar_id < vec::len(state.blocked) { + if condvar_id < state.blocked.len() { result = signal_waitqueue(&state.blocked[condvar_id]); } else { - out_of_bounds = Some(vec::len(state.blocked)); + out_of_bounds = Some(state.blocked.len()); } } do check_cvar_bounds(out_of_bounds, condvar_id, "cond.signal_on()") { @@ -304,14 +303,14 @@ pub impl<'self> Condvar<'self> { let mut out_of_bounds = None; let mut queue = None; do (**self.sem).with |state| { - if condvar_id < vec::len(state.blocked) { + if condvar_id < state.blocked.len() { // To avoid :broadcast_heavy, we make a new waitqueue, // swap it out with the old one, and broadcast on the // old one outside of the little-lock. queue = Some(util::replace(&mut state.blocked[condvar_id], new_waitqueue())); } else { - out_of_bounds = Some(vec::len(state.blocked)); + out_of_bounds = Some(state.blocked.len()); } } do check_cvar_bounds(out_of_bounds, condvar_id, "cond.signal_on()") { diff --git a/src/libstd/test.rs b/src/libstd/test.rs index 78f46b4ca03..b2f73df316d 100644 --- a/src/libstd/test.rs +++ b/src/libstd/test.rs @@ -144,7 +144,7 @@ pub fn parse_opts(args: &[~str]) -> OptRes { }; let filter = - if vec::len(matches.free) > 0 { + if matches.free.len() > 0 { option::Some(copy (matches).free[0]) } else { option::None }; @@ -901,7 +901,7 @@ mod tests { ]; let filtered = filter_tests(&opts, tests); - assert!((vec::len(filtered) == 1)); + assert!(filtered.len() == 1); assert!((filtered[0].desc.name.to_str() == ~"1")); assert!((filtered[0].desc.ignore == false)); } diff --git a/src/libstd/uv_ll.rs b/src/libstd/uv_ll.rs index a14c048b8de..37052f7d1b7 100644 --- a/src/libstd/uv_ll.rs +++ b/src/libstd/uv_ll.rs @@ -1358,7 +1358,7 @@ mod test { let req_msg_ptr: *u8 = vec::raw::to_ptr(req_str_bytes); debug!("req_msg ptr: %u", req_msg_ptr as uint); let req_msg = ~[ - buf_init(req_msg_ptr, vec::len(req_str_bytes)) + buf_init(req_msg_ptr, req_str_bytes.len()) ]; // this is the enclosing record, we'll pass a ptr to // this to C.. diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 94bd9a18589..f77d00ce9b1 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -17,6 +17,7 @@ use opt_vec::OptVec; use core::cast; use core::option::{None, Option, Some}; use core::to_bytes; +use core::to_bytes::IterBytes; use core::to_str::ToStr; use std::serialize::{Encodable, Decodable, Encoder, Decoder}; @@ -98,12 +99,14 @@ impl<D:Decoder> Decodable<D> for ident { #[cfg(stage0)] impl to_bytes::IterBytes for ident { + #[inline(always)] fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) { self.repr.iter_bytes(lsb0, f) } } #[cfg(not(stage0))] impl to_bytes::IterBytes for ident { + #[inline(always)] fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { self.repr.iter_bytes(lsb0, f) } @@ -121,6 +124,20 @@ pub struct Lifetime { ident: ident } +#[cfg(stage0)] +impl to_bytes::IterBytes for Lifetime { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) { + to_bytes::iter_bytes_3(&self.id, &self.span, &self.ident, lsb0, f) + } +} + +#[cfg(not(stage0))] +impl to_bytes::IterBytes for Lifetime { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { + to_bytes::iter_bytes_3(&self.id, &self.span, &self.ident, lsb0, f) + } +} + // a "Path" is essentially Rust's notion of a name; // for instance: core::cmp::Eq . It's represented // as a sequence of identifiers, along with a bunch @@ -752,7 +769,7 @@ pub struct ty_method { purity: purity, decl: fn_decl, generics: Generics, - self_ty: self_ty, + explicit_self: explicit_self, id: node_id, span: span, } @@ -1049,7 +1066,7 @@ impl to_bytes::IterBytes for ret_style { #[auto_encode] #[auto_decode] #[deriving(Eq)] -pub enum self_ty_ { +pub enum explicit_self_ { sty_static, // no self sty_value, // `self` sty_region(Option<@Lifetime>, mutability), // `&'lt self` @@ -1057,7 +1074,33 @@ pub enum self_ty_ { sty_uniq(mutability) // `~self` } -pub type self_ty = spanned<self_ty_>; +#[cfg(stage0)] +impl to_bytes::IterBytes for explicit_self_ { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) { + match *self { + sty_static => 0u8.iter_bytes(lsb0, f), + sty_value => 1u8.iter_bytes(lsb0, f), + sty_region(ref lft, ref mutbl) => to_bytes::iter_bytes_3(&2u8, &lft, mutbl, lsb0, f), + sty_box(ref mutbl) => to_bytes::iter_bytes_2(&3u8, mutbl, lsb0, f), + sty_uniq(ref mutbl) => to_bytes::iter_bytes_2(&4u8, mutbl, lsb0, f), + } + } +} + +#[cfg(not(stage0))] +impl to_bytes::IterBytes for explicit_self_ { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { + match *self { + sty_static => 0u8.iter_bytes(lsb0, f), + sty_value => 1u8.iter_bytes(lsb0, f), + sty_region(ref lft, ref mutbl) => to_bytes::iter_bytes_3(&2u8, &lft, mutbl, lsb0, f), + sty_box(ref mutbl) => to_bytes::iter_bytes_2(&3u8, mutbl, lsb0, f), + sty_uniq(ref mutbl) => to_bytes::iter_bytes_2(&4u8, mutbl, lsb0, f), + } + } +} + +pub type explicit_self = spanned<explicit_self_>; #[auto_encode] #[auto_decode] @@ -1066,7 +1109,7 @@ pub struct method { ident: ident, attrs: ~[attribute], generics: Generics, - self_ty: self_ty, + explicit_self: explicit_self, purity: purity, decl: fn_decl, body: blk, diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index 212ceadf912..a98e3002dcf 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -272,7 +272,7 @@ pub fn trait_method_to_ty_method(method: &trait_method) -> ty_method { purity: m.purity, decl: copy m.decl, generics: copy m.generics, - self_ty: m.self_ty, + explicit_self: m.explicit_self, id: m.id, span: m.span, } diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs index e0392b476e4..cd0b29f2a1e 100644 --- a/src/libsyntax/codemap.rs +++ b/src/libsyntax/codemap.rs @@ -152,6 +152,20 @@ impl<D:Decoder> Decodable<D> for span { } } +#[cfg(stage0)] +impl to_bytes::IterBytes for span { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) { + to_bytes::iter_bytes_3(&self.lo, &self.hi, &self.expn_info, lsb0, f); + } +} + +#[cfg(not(stage0))] +impl to_bytes::IterBytes for span { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { + to_bytes::iter_bytes_3(&self.lo, &self.hi, &self.expn_info, lsb0, f) + } +} + pub fn spanned<T>(lo: BytePos, hi: BytePos, t: T) -> spanned<T> { respan(mk_sp(lo, hi), t) } @@ -199,16 +213,62 @@ pub struct FileMapAndLine {fm: @FileMap, line: uint} pub struct FileMapAndBytePos {fm: @FileMap, pos: BytePos} pub struct NameAndSpan {name: ~str, span: Option<span>} +#[cfg(stage0)] +impl to_bytes::IterBytes for NameAndSpan { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) { + to_bytes::iter_bytes_2(&self.name, &self.span, lsb0, f) + } +} + +#[cfg(not(stage0))] +impl to_bytes::IterBytes for NameAndSpan { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { + to_bytes::iter_bytes_2(&self.name, &self.span, lsb0, f) + } +} + pub struct CallInfo { call_site: span, callee: NameAndSpan } +#[cfg(stage0)] +impl to_bytes::IterBytes for CallInfo { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) { + to_bytes::iter_bytes_2(&self.call_site, &self.callee, lsb0, f) + } +} + +#[cfg(not(stage0))] +impl to_bytes::IterBytes for CallInfo { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { + to_bytes::iter_bytes_2(&self.call_site, &self.callee, lsb0, f) + } +} + /// Extra information for tracking macro expansion of spans pub enum ExpnInfo { ExpandedFrom(CallInfo) } +#[cfg(stage0)] +impl to_bytes::IterBytes for ExpnInfo { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) { + match *self { + ExpandedFrom(ref call_info) => to_bytes::iter_bytes_2(&0u8, call_info, lsb0, f) + } + } +} + +#[cfg(not(stage0))] +impl to_bytes::IterBytes for ExpnInfo { + fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { + match *self { + ExpandedFrom(ref call_info) => to_bytes::iter_bytes_2(&0u8, call_info, lsb0, f) + } + } +} + pub type FileName = ~str; pub struct FileLines diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs index 6b2aa2416f8..993fa612a27 100644 --- a/src/libsyntax/diagnostic.rs +++ b/src/libsyntax/diagnostic.rs @@ -232,7 +232,7 @@ fn highlight_lines(cm: @codemap::CodeMap, let max_lines = 6u; let mut elided = false; let mut display_lines = /* FIXME (#2543) */ copy lines.lines; - if vec::len(display_lines) > max_lines { + if display_lines.len() > max_lines { display_lines = vec::slice(display_lines, 0u, max_lines).to_vec(); elided = true; } @@ -243,7 +243,7 @@ fn highlight_lines(cm: @codemap::CodeMap, io::stderr().write_str(s); } if elided { - let last_line = display_lines[vec::len(display_lines) - 1u]; + let last_line = display_lines[display_lines.len() - 1u]; let s = fmt!("%s:%u ", fm.name, last_line + 1u); let mut indent = str::len(s); let mut out = ~""; @@ -254,7 +254,7 @@ fn highlight_lines(cm: @codemap::CodeMap, // FIXME (#3260) // If there's one line at fault we can easily point to the problem - if vec::len(lines.lines) == 1u { + if lines.lines.len() == 1u { let lo = cm.lookup_char_pos(sp.lo); let mut digits = 0u; let mut num = (lines.lines[0] + 1u) / 10u; diff --git a/src/libsyntax/ext/auto_encode.rs b/src/libsyntax/ext/auto_encode.rs index ac86d266d73..5c306aefc6a 100644 --- a/src/libsyntax/ext/auto_encode.rs +++ b/src/libsyntax/ext/auto_encode.rs @@ -713,7 +713,7 @@ fn mk_ser_method( ident: cx.ident_of("encode"), attrs: ~[], generics: ast_util::empty_generics(), - self_ty: codemap::spanned { + explicit_self: codemap::spanned { node: ast::sty_region(None, ast::m_imm), span: span }, @@ -772,7 +772,7 @@ fn mk_deser_method( ident: cx.ident_of("decode"), attrs: ~[], generics: ast_util::empty_generics(), - self_ty: codemap::spanned { node: ast::sty_static, span: span }, + explicit_self: codemap::spanned { node: ast::sty_static, span: span }, purity: ast::impure_fn, decl: deser_decl, body: deser_body, @@ -824,7 +824,7 @@ fn mk_struct_ser_impl( cx.ident_of("emit_struct"), ~[ cx.lit_str(span, @cx.str_of(ident)), - cx.lit_uint(span, vec::len(fields)), + cx.lit_uint(span, fields.len()), cx.lambda_stmts_1(span, fields, cx.ident_of("__s")), ] ); @@ -886,7 +886,7 @@ fn mk_struct_deser_impl( cx.ident_of("read_struct"), ~[ cx.lit_str(span, @cx.str_of(ident)), - cx.lit_uint(span, vec::len(fields)), + cx.lit_uint(span, fields.len()), cx.lambda_expr_1( cx.expr( span, diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index 20bf01c0dc1..30470d2ebe7 100644 --- a/src/libsyntax/ext/base.rs +++ b/src/libsyntax/ext/base.rs @@ -351,7 +351,7 @@ pub fn expr_to_ident(cx: @ext_ctxt, err_msg: &str) -> ast::ident { match expr.node { ast::expr_path(p) => { - if vec::len(p.types) > 0u || vec::len(p.idents) != 1u { + if p.types.len() > 0u || p.idents.len() != 1u { cx.span_fatal(expr.span, err_msg); } return p.idents[0]; diff --git a/src/libsyntax/ext/deriving/clone.rs b/src/libsyntax/ext/deriving/clone.rs index 2151e9529c4..1a45107c267 100644 --- a/src/libsyntax/ext/deriving/clone.rs +++ b/src/libsyntax/ext/deriving/clone.rs @@ -28,7 +28,7 @@ pub fn expand_deriving_clone(cx: @ext_ctxt, MethodDef { name: ~"clone", generics: LifetimeBounds::empty(), - self_ty: borrowed_explicit_self(), + explicit_self: borrowed_explicit_self(), args: ~[], ret_ty: Self, const_nonmatching: false, diff --git a/src/libsyntax/ext/deriving/cmp/eq.rs b/src/libsyntax/ext/deriving/cmp/eq.rs index e431e1f78bf..7fc2fdc7963 100644 --- a/src/libsyntax/ext/deriving/cmp/eq.rs +++ b/src/libsyntax/ext/deriving/cmp/eq.rs @@ -34,7 +34,7 @@ pub fn expand_deriving_eq(cx: @ext_ctxt, MethodDef { name: $name, generics: LifetimeBounds::empty(), - self_ty: borrowed_explicit_self(), + explicit_self: borrowed_explicit_self(), args: ~[borrowed_self()], ret_ty: Literal(Path::new(~[~"bool"])), const_nonmatching: true, diff --git a/src/libsyntax/ext/deriving/cmp/ord.rs b/src/libsyntax/ext/deriving/cmp/ord.rs index cdb9f620301..5445aef4491 100644 --- a/src/libsyntax/ext/deriving/cmp/ord.rs +++ b/src/libsyntax/ext/deriving/cmp/ord.rs @@ -24,7 +24,7 @@ pub fn expand_deriving_ord(cx: @ext_ctxt, MethodDef { name: $name, generics: LifetimeBounds::empty(), - self_ty: borrowed_explicit_self(), + explicit_self: borrowed_explicit_self(), args: ~[borrowed_self()], ret_ty: Literal(Path::new(~[~"bool"])), const_nonmatching: false, diff --git a/src/libsyntax/ext/deriving/cmp/totaleq.rs b/src/libsyntax/ext/deriving/cmp/totaleq.rs index 068a7bc06b1..4541569b829 100644 --- a/src/libsyntax/ext/deriving/cmp/totaleq.rs +++ b/src/libsyntax/ext/deriving/cmp/totaleq.rs @@ -33,7 +33,7 @@ pub fn expand_deriving_totaleq(cx: @ext_ctxt, MethodDef { name: ~"equals", generics: LifetimeBounds::empty(), - self_ty: borrowed_explicit_self(), + explicit_self: borrowed_explicit_self(), args: ~[borrowed_self()], ret_ty: Literal(Path::new(~[~"bool"])), const_nonmatching: true, diff --git a/src/libsyntax/ext/deriving/cmp/totalord.rs b/src/libsyntax/ext/deriving/cmp/totalord.rs index 5ec4e028454..8f156e6a9e3 100644 --- a/src/libsyntax/ext/deriving/cmp/totalord.rs +++ b/src/libsyntax/ext/deriving/cmp/totalord.rs @@ -27,7 +27,7 @@ pub fn expand_deriving_totalord(cx: @ext_ctxt, MethodDef { name: ~"cmp", generics: LifetimeBounds::empty(), - self_ty: borrowed_explicit_self(), + explicit_self: borrowed_explicit_self(), args: ~[borrowed_self()], ret_ty: Literal(Path::new(~[~"core", ~"cmp", ~"Ordering"])), const_nonmatching: false, diff --git a/src/libsyntax/ext/deriving/decodable.rs b/src/libsyntax/ext/deriving/decodable.rs index fd5d26a1787..3be65ecd8db 100644 --- a/src/libsyntax/ext/deriving/decodable.rs +++ b/src/libsyntax/ext/deriving/decodable.rs @@ -119,13 +119,13 @@ fn create_decode_method( let body_block = build::mk_simple_block(cx, span, expr); // Create the method. - let self_ty = spanned { node: sty_static, span: span }; + let explicit_self = spanned { node: sty_static, span: span }; let method_ident = cx.ident_of("decode"); @ast::method { ident: method_ident, attrs: ~[], generics: ast_util::empty_generics(), - self_ty: self_ty, + explicit_self: explicit_self, purity: impure_fn, decl: fn_decl, body: body_block, diff --git a/src/libsyntax/ext/deriving/encodable.rs b/src/libsyntax/ext/deriving/encodable.rs index a5edd92022f..2078ec9d45c 100644 --- a/src/libsyntax/ext/deriving/encodable.rs +++ b/src/libsyntax/ext/deriving/encodable.rs @@ -111,13 +111,13 @@ fn create_encode_method( let body_block = build::mk_block_(cx, span, statements); // Create the method. - let self_ty = spanned { node: sty_region(None, m_imm), span: span }; + let explicit_self = spanned { node: sty_region(None, m_imm), span: span }; let method_ident = cx.ident_of("encode"); @ast::method { ident: method_ident, attrs: ~[], generics: ast_util::empty_generics(), - self_ty: self_ty, + explicit_self: explicit_self, purity: impure_fn, decl: fn_decl, body: body_block, diff --git a/src/libsyntax/ext/deriving/generic.rs b/src/libsyntax/ext/deriving/generic.rs index be2cc6dd25e..fc14e3c3f73 100644 --- a/src/libsyntax/ext/deriving/generic.rs +++ b/src/libsyntax/ext/deriving/generic.rs @@ -216,7 +216,7 @@ pub struct MethodDef<'self> { /// Whether there is a self argument (outer Option) i.e. whether /// this is a static function, and whether it is a pointer (inner /// Option) - self_ty: Option<Option<PtrTy>>, + explicit_self: Option<Option<PtrTy>>, /// Arguments other than the self argument args: ~[Ty], @@ -321,7 +321,7 @@ impl<'self> TraitDef<'self> { type_ident: ident, generics: &Generics) -> @ast::item { let methods = do self.methods.map |method_def| { - let (self_ty, self_args, nonself_args, tys) = + let (explicit_self, self_args, nonself_args, tys) = method_def.split_self_nonself_args(cx, span, type_ident, generics); let body = if method_def.is_static() { @@ -339,7 +339,7 @@ impl<'self> TraitDef<'self> { method_def.create_method(cx, span, type_ident, generics, - self_ty, tys, + explicit_self, tys, body) }; @@ -352,7 +352,7 @@ impl<'self> TraitDef<'self> { type_ident: ident, generics: &Generics) -> @ast::item { let methods = do self.methods.map |method_def| { - let (self_ty, self_args, nonself_args, tys) = + let (explicit_self, self_args, nonself_args, tys) = method_def.split_self_nonself_args(cx, span, type_ident, generics); let body = if method_def.is_static() { @@ -370,7 +370,7 @@ impl<'self> TraitDef<'self> { method_def.create_method(cx, span, type_ident, generics, - self_ty, tys, + explicit_self, tys, body) }; @@ -404,28 +404,27 @@ impl<'self> MethodDef<'self> { } fn is_static(&self) -> bool { - self.self_ty.is_none() + self.explicit_self.is_none() } fn split_self_nonself_args(&self, cx: @ext_ctxt, span: span, type_ident: ident, generics: &Generics) - -> (ast::self_ty, ~[@expr], ~[@expr], ~[(ident, @ast::Ty)]) { + -> (ast::explicit_self, ~[@expr], ~[@expr], ~[(ident, @ast::Ty)]) { let mut self_args = ~[], nonself_args = ~[], arg_tys = ~[]; - let mut ast_self_ty = respan(span, ast::sty_static); let mut nonstatic = false; - match self.self_ty { + let ast_explicit_self = match self.explicit_self { Some(ref self_ptr) => { - let (self_expr, self_ty) = ty::get_explicit_self(cx, span, - self_ptr); + let (self_expr, explicit_self) = ty::get_explicit_self(cx, span, self_ptr); - ast_self_ty = self_ty; self_args.push(self_expr); nonstatic = true; + + explicit_self } - _ => {} - } + None => respan(span, ast::sty_static), + }; for self.args.eachi |i, ty| { let ast_ty = ty.to_ty(cx, span, type_ident, generics); @@ -449,13 +448,13 @@ impl<'self> MethodDef<'self> { } } - (ast_self_ty, self_args, nonself_args, arg_tys) + (ast_explicit_self, self_args, nonself_args, arg_tys) } fn create_method(&self, cx: @ext_ctxt, span: span, type_ident: ident, generics: &Generics, - self_ty: ast::self_ty, + explicit_self: ast::explicit_self, arg_types: ~[(ident, @ast::Ty)], body: @expr) -> @ast::method { // create the generics that aren't for Self @@ -477,7 +476,7 @@ impl<'self> MethodDef<'self> { ident: method_ident, attrs: ~[], generics: fn_generics, - self_ty: self_ty, + explicit_self: explicit_self, purity: ast::impure_fn, decl: fn_decl, body: body_block, diff --git a/src/libsyntax/ext/deriving/iter_bytes.rs b/src/libsyntax/ext/deriving/iter_bytes.rs index 9eb246ffe22..27e3a54add5 100644 --- a/src/libsyntax/ext/deriving/iter_bytes.rs +++ b/src/libsyntax/ext/deriving/iter_bytes.rs @@ -26,7 +26,7 @@ pub fn expand_deriving_iter_bytes(cx: @ext_ctxt, MethodDef { name: ~"iter_bytes", generics: LifetimeBounds::empty(), - self_ty: borrowed_explicit_self(), + explicit_self: borrowed_explicit_self(), args: ~[ Literal(Path::new(~[~"bool"])), Literal(Path::new(~[~"core", ~"to_bytes", ~"Cb"])) diff --git a/src/libsyntax/ext/deriving/rand.rs b/src/libsyntax/ext/deriving/rand.rs index 9030be86f39..2d91fcd346a 100644 --- a/src/libsyntax/ext/deriving/rand.rs +++ b/src/libsyntax/ext/deriving/rand.rs @@ -32,7 +32,7 @@ pub fn expand_deriving_rand(cx: @ext_ctxt, bounds: ~[(~"R", ~[ Path::new(~[~"core", ~"rand", ~"Rng"]) ])] }, - self_ty: None, + explicit_self: None, args: ~[ Ptr(~Literal(Path::new_local(~"R")), Borrowed(None, ast::m_mutbl)) diff --git a/src/libsyntax/ext/deriving/to_str.rs b/src/libsyntax/ext/deriving/to_str.rs index 6010354349e..13cb09e970d 100644 --- a/src/libsyntax/ext/deriving/to_str.rs +++ b/src/libsyntax/ext/deriving/to_str.rs @@ -27,7 +27,7 @@ pub fn expand_deriving_to_str(cx: @ext_ctxt, MethodDef { name: ~"to_str", generics: LifetimeBounds::empty(), - self_ty: borrowed_explicit_self(), + explicit_self: borrowed_explicit_self(), args: ~[], ret_ty: Ptr(~Literal(Path::new_local(~"str")), Owned), const_nonmatching: false, diff --git a/src/libsyntax/ext/deriving/ty.rs b/src/libsyntax/ext/deriving/ty.rs index 768ac7458d6..8fd372e4792 100644 --- a/src/libsyntax/ext/deriving/ty.rs +++ b/src/libsyntax/ext/deriving/ty.rs @@ -217,7 +217,7 @@ pub impl LifetimeBounds { pub fn get_explicit_self(cx: @ext_ctxt, span: span, self_ptr: &Option<PtrTy>) - -> (@expr, ast::self_ty) { + -> (@expr, ast::explicit_self) { let self_path = build::make_self(cx, span); match *self_ptr { None => { diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index 9afbe1e479d..f9ca84473fb 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -542,7 +542,41 @@ pub fn core_macros() -> ~str { } ) - + // + // A scheme-style conditional that helps to improve code clarity in some instances when + // the `if`, `else if`, and `else` keywords obscure predicates undesirably. + // + // # Example + // + // ~~~ + // let clamped = + // if x > mx { mx } + // else if x < mn { mn } + // else { x }; + // ~~~ + // + // Using `cond!`, the above could be written as: + // + // ~~~ + // let clamped = cond!( + // (x > mx) { mx } + // (x < mn) { mn } + // _ { x } + // ); + // ~~~ + // + // The optional default case is denoted by `_`. + // + macro_rules! cond ( + ( $(($pred:expr) $body:block)+ _ $default:block ) => ( + $(if $pred $body else)+ + $default + ); + // for if the default case was ommitted + ( $(($pred:expr) $body:block)+ ) => ( + $(if $pred $body)else+ + ); + ) }"; } diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index 6ed8994ed33..f6dbbbf420d 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -323,7 +323,7 @@ fn noop_fold_method(m: @method, fld: @ast_fold) -> @method { ident: fld.fold_ident(m.ident), attrs: /* FIXME (#2543) */ copy m.attrs, generics: fold_generics(&m.generics, fld), - self_ty: m.self_ty, + explicit_self: m.explicit_self, purity: m.purity, decl: fold_fn_decl(&m.decl, fld), body: fld.fold_block(&m.body), diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs index fa91b968f69..89873b27935 100644 --- a/src/libsyntax/parse/comments.rs +++ b/src/libsyntax/parse/comments.rs @@ -276,7 +276,7 @@ fn read_block_comment(rdr: @mut StringReader, let mut style = if code_to_the_left { trailing } else { isolated }; consume_non_eol_whitespace(rdr); - if !is_eof(rdr) && rdr.curr != '\n' && vec::len(lines) == 1u { + if !is_eof(rdr) && rdr.curr != '\n' && lines.len() == 1u { style = mixed; } debug!("<<< block comment"); diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index e1fe20695c7..b76098858cb 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -19,7 +19,7 @@ use ast::{_mod, add, arg, arm, attribute, bind_by_ref, bind_infer}; use ast::{bind_by_copy, bitand, bitor, bitxor, blk}; use ast::{blk_check_mode, box}; use ast::{crate, crate_cfg, decl, decl_item}; -use ast::{decl_local, default_blk, deref, div, enum_def}; +use ast::{decl_local, default_blk, deref, div, enum_def, explicit_self}; use ast::{expr, expr_, expr_addr_of, expr_match, expr_again}; use ast::{expr_assign, expr_assign_op, expr_binary, expr_block}; use ast::{expr_break, expr_call, expr_cast, expr_copy, expr_do_body}; @@ -43,7 +43,7 @@ use ast::{named_field, neg, node_id, noreturn, not, pat, pat_box, pat_enum}; use ast::{pat_ident, pat_lit, pat_range, pat_region, pat_struct}; use ast::{pat_tup, pat_uniq, pat_wild, private}; use ast::{rem, required}; -use ast::{ret_style, return_val, self_ty, shl, shr, stmt, stmt_decl}; +use ast::{ret_style, return_val, shl, shr, stmt, stmt_decl}; use ast::{stmt_expr, stmt_semi, stmt_mac, struct_def, struct_field}; use ast::{struct_variant_kind, subtract}; use ast::{sty_box, sty_region, sty_static, sty_uniq, sty_value}; @@ -504,7 +504,7 @@ pub impl Parser { let generics = p.parse_generics(); - let (self_ty, d) = do self.parse_fn_decl_with_self() |p| { + let (explicit_self, d) = do self.parse_fn_decl_with_self() |p| { // This is somewhat dubious; We don't want to allow argument // names to be left off if there is a definition... either::Left(p.parse_arg_general(false)) @@ -526,7 +526,7 @@ pub impl Parser { purity: pur, decl: d, generics: generics, - self_ty: self_ty, + explicit_self: explicit_self, id: p.get_id(), span: mk_sp(lo, hi) }) @@ -540,7 +540,7 @@ pub impl Parser { ident: ident, attrs: attrs, generics: generics, - self_ty: self_ty, + explicit_self: explicit_self, purity: pur, decl: d, body: body, @@ -2471,7 +2471,7 @@ pub impl Parser { } }, _ => { - if vec::len(enum_path.idents)==1u { + if enum_path.idents.len()==1u { // it could still be either an enum // or an identifier pattern, resolve // will sort it out: @@ -3002,11 +3002,11 @@ pub impl Parser { &self, parse_arg_fn: &fn(&Parser) -> arg_or_capture_item - ) -> (self_ty, fn_decl) { - fn maybe_parse_self_ty( - cnstr: &fn(v: mutability) -> ast::self_ty_, + ) -> (explicit_self, fn_decl) { + fn maybe_parse_explicit_self( + cnstr: &fn(v: mutability) -> ast::explicit_self_, p: &Parser - ) -> ast::self_ty_ { + ) -> ast::explicit_self_ { // We need to make sure it isn't a mode or a type if p.token_is_keyword(&~"self", &p.look_ahead(1)) || ((p.token_is_keyword(&~"const", &p.look_ahead(1)) || @@ -3022,7 +3022,7 @@ pub impl Parser { } } - fn maybe_parse_borrowed_self_ty(this: &Parser) -> ast::self_ty_ { + fn maybe_parse_borrowed_explicit_self(this: &Parser) -> ast::explicit_self_ { // The following things are possible to see here: // // fn(&self) @@ -3066,15 +3066,15 @@ pub impl Parser { // A bit of complexity and lookahead is needed here in order to to be // backwards compatible. let lo = self.span.lo; - let self_ty = match *self.token { + let explicit_self = match *self.token { token::BINOP(token::AND) => { - maybe_parse_borrowed_self_ty(self) + maybe_parse_borrowed_explicit_self(self) } token::AT => { - maybe_parse_self_ty(sty_box, self) + maybe_parse_explicit_self(sty_box, self) } token::TILDE => { - maybe_parse_self_ty(sty_uniq, self) + maybe_parse_explicit_self(sty_uniq, self) } token::IDENT(*) if self.is_self_ident() => { self.bump(); @@ -3087,7 +3087,7 @@ pub impl Parser { // If we parsed a self type, expect a comma before the argument list. let args_or_capture_items; - if self_ty != sty_static { + if explicit_self != sty_static { match *self.token { token::COMMA => { self.bump(); @@ -3132,7 +3132,7 @@ pub impl Parser { cf: ret_style }; - (spanned(lo, hi, self_ty), fn_decl) + (spanned(lo, hi, explicit_self), fn_decl) } // parse the |arg, arg| header on a lambda @@ -3199,7 +3199,7 @@ pub impl Parser { let pur = self.parse_fn_purity(); let ident = self.parse_ident(); let generics = self.parse_generics(); - let (self_ty, decl) = do self.parse_fn_decl_with_self() |p| { + let (explicit_self, decl) = do self.parse_fn_decl_with_self() |p| { p.parse_arg() }; @@ -3210,7 +3210,7 @@ pub impl Parser { ident: ident, attrs: attrs, generics: generics, - self_ty: self_ty, + explicit_self: explicit_self, purity: pur, decl: decl, body: body, @@ -4337,7 +4337,7 @@ pub impl Parser { } _ => () } - let last = path[vec::len(path) - 1u]; + let last = path[path.len() - 1u]; let path = @ast::Path { span: mk_sp(lo, self.span.hi), global: false, idents: path, diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index 27686c4e4aa..fe479ab81f7 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -357,12 +357,14 @@ impl<'self> Equiv<@~str> for StringRef<'self> { #[cfg(stage0)] impl<'self> to_bytes::IterBytes for StringRef<'self> { + #[inline(always)] fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) { (**self).iter_bytes(lsb0, f); } } #[cfg(not(stage0))] impl<'self> to_bytes::IterBytes for StringRef<'self> { + #[inline(always)] fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool { (**self).iter_bytes(lsb0, f) } diff --git a/src/libsyntax/print/pp.rs b/src/libsyntax/print/pp.rs index 7944469cb96..38c58612f43 100644 --- a/src/libsyntax/print/pp.rs +++ b/src/libsyntax/print/pp.rs @@ -110,8 +110,8 @@ pub fn tok_str(t: token) -> ~str { pub fn buf_str(toks: ~[token], szs: ~[int], left: uint, right: uint, lim: uint) -> ~str { - let n = vec::len(toks); - assert!(n == vec::len(szs)); + let n = toks.len(); + assert!(n == szs.len()); let mut i = left; let mut L = lim; let mut s = ~"["; diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 1e94c16f87a..ea1682978a4 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -181,12 +181,12 @@ pub fn path_to_str(p: @ast::Path, intr: @ident_interner) -> ~str { } pub fn fun_to_str(decl: &ast::fn_decl, purity: ast::purity, name: ast::ident, - opt_self_ty: Option<ast::self_ty_>, + opt_explicit_self: Option<ast::explicit_self_>, generics: &ast::Generics, intr: @ident_interner) -> ~str { do io::with_str_writer |wr| { let s = rust_printer(wr, intr); print_fn(s, decl, Some(purity), AbiSet::Rust(), - name, generics, opt_self_ty, ast::inherited); + name, generics, opt_explicit_self, ast::inherited); end(s); // Close the head box end(s); // Close the outer box eof(s.s); @@ -797,7 +797,7 @@ pub fn print_ty_method(s: @ps, m: &ast::ty_method) { print_outer_attributes(s, m.attrs); print_ty_fn(s, None, None, None, m.purity, ast::Many, &m.decl, Some(m.ident), Some(&m.generics), - Some(/*bad*/ copy m.self_ty.node)); + Some(/*bad*/ copy m.explicit_self.node)); word(s.s, ~";"); } @@ -813,7 +813,7 @@ pub fn print_method(s: @ps, meth: @ast::method) { maybe_print_comment(s, meth.span.lo); print_outer_attributes(s, meth.attrs); print_fn(s, &meth.decl, Some(meth.purity), AbiSet::Rust(), - meth.ident, &meth.generics, Some(meth.self_ty.node), + meth.ident, &meth.generics, Some(meth.explicit_self.node), meth.vis); word(s.s, ~" "); print_block_with_attrs(s, &meth.body, meth.attrs); @@ -1626,13 +1626,13 @@ pub fn print_pat(s: @ps, pat: @ast::pat, refutable: bool) { (s.ann.post)(ann_node); } -pub fn self_ty_to_str(self_ty: ast::self_ty_, intr: @ident_interner) -> ~str { - to_str(self_ty, |a, b| { print_self_ty(a, b); () }, intr) +pub fn explicit_self_to_str(explicit_self: ast::explicit_self_, intr: @ident_interner) -> ~str { + to_str(explicit_self, |a, b| { print_explicit_self(a, b); () }, intr) } // Returns whether it printed anything -pub fn print_self_ty(s: @ps, self_ty: ast::self_ty_) -> bool { - match self_ty { +pub fn print_explicit_self(s: @ps, explicit_self: ast::explicit_self_) -> bool { + match explicit_self { ast::sty_static => { return false; } ast::sty_value => { word(s.s, ~"self"); } ast::sty_region(lt, m) => { @@ -1657,24 +1657,24 @@ pub fn print_fn(s: @ps, abis: AbiSet, name: ast::ident, generics: &ast::Generics, - opt_self_ty: Option<ast::self_ty_>, + opt_explicit_self: Option<ast::explicit_self_>, vis: ast::visibility) { head(s, ~""); - print_fn_header_info(s, opt_self_ty, purity, abis, ast::Many, None, vis); + print_fn_header_info(s, opt_explicit_self, purity, abis, ast::Many, None, vis); nbsp(s); print_ident(s, name); print_generics(s, generics); - print_fn_args_and_ret(s, decl, opt_self_ty); + print_fn_args_and_ret(s, decl, opt_explicit_self); } pub fn print_fn_args(s: @ps, decl: &ast::fn_decl, - opt_self_ty: Option<ast::self_ty_>) { + opt_explicit_self: Option<ast::explicit_self_>) { // It is unfortunate to duplicate the commasep logic, but we we want the // self type and the args all in the same box. box(s, 0u, inconsistent); let mut first = true; - for opt_self_ty.each |self_ty| { - first = !print_self_ty(s, *self_ty); + for opt_explicit_self.each |explicit_self| { + first = !print_explicit_self(s, *explicit_self); } for decl.inputs.each |arg| { @@ -1686,9 +1686,9 @@ pub fn print_fn_args(s: @ps, decl: &ast::fn_decl, } pub fn print_fn_args_and_ret(s: @ps, decl: &ast::fn_decl, - opt_self_ty: Option<ast::self_ty_>) { + opt_explicit_self: Option<ast::explicit_self_>) { popen(s); - print_fn_args(s, decl, opt_self_ty); + print_fn_args(s, decl, opt_explicit_self); pclose(s); maybe_print_comment(s, decl.output.span.lo); @@ -1798,7 +1798,7 @@ pub fn print_meta_item(s: @ps, item: @ast::meta_item) { pub fn print_view_path(s: @ps, vp: @ast::view_path) { match vp.node { ast::view_path_simple(ident, path, _) => { - if path.idents[vec::len(path.idents)-1u] != ident { + if path.idents[path.idents.len()-1u] != ident { print_ident(s, ident); space(s.s); word_space(s, ~"="); @@ -1900,7 +1900,7 @@ pub fn print_ty_fn(s: @ps, decl: &ast::fn_decl, id: Option<ast::ident>, generics: Option<&ast::Generics>, - opt_self_ty: Option<ast::self_ty_>) { + opt_explicit_self: Option<ast::explicit_self_>) { ibox(s, indent_unit); // Duplicates the logic in `print_fn_header_info()`. This is because that @@ -1920,8 +1920,8 @@ pub fn print_ty_fn(s: @ps, // self type and the args all in the same box. box(s, 0u, inconsistent); let mut first = true; - for opt_self_ty.each |self_ty| { - first = !print_self_ty(s, *self_ty); + for opt_explicit_self.each |explicit_self| { + first = !print_explicit_self(s, *explicit_self); } for decl.inputs.each |arg| { if first { first = false; } else { word_space(s, ~","); } @@ -2067,7 +2067,7 @@ pub fn maybe_print_comment(s: @ps, pos: BytePos) { pub fn print_comment(s: @ps, cmnt: &comments::cmnt) { match cmnt.style { comments::mixed => { - assert!((vec::len(cmnt.lines) == 1u)); + assert!(cmnt.lines.len() == 1u); zerobreak(s.s); word(s.s, cmnt.lines[0]); zerobreak(s.s); @@ -2083,7 +2083,7 @@ pub fn print_comment(s: @ps, cmnt: &comments::cmnt) { } comments::trailing => { word(s.s, ~" "); - if vec::len(cmnt.lines) == 1u { + if cmnt.lines.len() == 1u { word(s.s, cmnt.lines[0]); hardbreak(s.s); } else { @@ -2163,7 +2163,7 @@ pub fn print_opt_sigil(s: @ps, opt_sigil: Option<ast::Sigil>) { } pub fn print_fn_header_info(s: @ps, - _opt_sty: Option<ast::self_ty_>, + _opt_explicit_self: Option<ast::explicit_self_>, opt_purity: Option<ast::purity>, abis: AbiSet, onceness: ast::Onceness, diff --git a/src/test/auxiliary/cci_iter_lib.rs b/src/test/auxiliary/cci_iter_lib.rs index e44267373ef..a264c7d238f 100644 --- a/src/test/auxiliary/cci_iter_lib.rs +++ b/src/test/auxiliary/cci_iter_lib.rs @@ -13,7 +13,7 @@ #[inline] pub fn iter<T>(v: &[T], f: &fn(&T)) { let mut i = 0u; - let n = vec::len(v); + let n = v.len(); while i < n { f(&v[i]); i += 1u; diff --git a/src/test/auxiliary/cci_no_inline_lib.rs b/src/test/auxiliary/cci_no_inline_lib.rs index f79227d87cd..fbdb7806b5e 100644 --- a/src/test/auxiliary/cci_no_inline_lib.rs +++ b/src/test/auxiliary/cci_no_inline_lib.rs @@ -13,7 +13,7 @@ // same as cci_iter_lib, more-or-less, but not marked inline pub fn iter(v: ~[uint], f: &fn(uint)) { let mut i = 0u; - let n = vec::len(v); + let n = v.len(); while i < n { f(v[i]); i += 1u; diff --git a/src/test/bench/graph500-bfs.rs b/src/test/bench/graph500-bfs.rs index 6fd31aa7b9f..ddf6f4bfc55 100644 --- a/src/test/bench/graph500-bfs.rs +++ b/src/test/bench/graph500-bfs.rs @@ -126,7 +126,7 @@ fn gen_search_keys(graph: &[~[node_id]], n: uint) -> ~[node_id] { */ fn bfs(graph: graph, key: node_id) -> bfs_result { let mut marks : ~[node_id] - = vec::from_elem(vec::len(graph), -1i64); + = vec::from_elem(graph.len(), -1i64); let mut q = Deque::new(); @@ -429,7 +429,7 @@ fn main() { let stop = time::precise_time_s(); io::stdout().write_line(fmt!("Generated %? edges in %? seconds.", - vec::len(edges), stop - start)); + edges.len(), stop - start)); let start = time::precise_time_s(); let graph = make_graph(1 << scale, copy edges); diff --git a/src/test/bench/shootout-k-nucleotide-pipes.rs b/src/test/bench/shootout-k-nucleotide-pipes.rs index fa6b7066e40..3c32ec338b7 100644 --- a/src/test/bench/shootout-k-nucleotide-pipes.rs +++ b/src/test/bench/shootout-k-nucleotide-pipes.rs @@ -95,7 +95,7 @@ fn windows_with_carry(bb: &[u8], nn: uint, it: &fn(window: &[u8])) -> ~[u8] { let mut ii = 0u; - let len = vec::len(bb); + let len = bb.len(); while ii < len - (nn - 1u) { it(vec::slice(bb, ii, ii+nn)); ii += 1u; diff --git a/src/test/bench/sudoku.rs b/src/test/bench/sudoku.rs index c383cdf4318..c18c1eaedd6 100644 --- a/src/test/bench/sudoku.rs +++ b/src/test/bench/sudoku.rs @@ -70,7 +70,7 @@ pub impl Sudoku { let line = reader.read_line(); let mut comps = ~[]; for str::each_split_char(line.trim(), ',') |s| { comps.push(s.to_owned()) } - if vec::len(comps) == 3u { + if comps.len() == 3u { let row = uint::from_str(comps[0]).get() as u8; let col = uint::from_str(comps[1]).get() as u8; g[row][col] = uint::from_str(comps[2]).get() as u8; @@ -103,7 +103,7 @@ pub impl Sudoku { } let mut ptr = 0u; - let end = vec::len(work); + let end = work.len(); while (ptr < end) { let (row, col) = work[ptr]; // is there another color to try? @@ -265,7 +265,7 @@ fn check_default_sudoku_solution() { fn main() { let args = os::args(); - let use_default = vec::len(args) == 1u; + let use_default = args.len() == 1u; let mut sudoku = if use_default { Sudoku::from_vec(&default_sudoku) } else { diff --git a/src/test/compile-fail/issue-2123.rs b/src/test/compile-fail/issue-2123.rs index 56f0c5e3dd0..6d617d338ed 100644 --- a/src/test/compile-fail/issue-2123.rs +++ b/src/test/compile-fail/issue-2123.rs @@ -9,6 +9,7 @@ // except according to those terms. use x = m::f; //~ ERROR failed to resolve import + //~^ unresolved import: there is no `f` in `m` mod m { } diff --git a/src/test/compile-fail/issue-2937.rs b/src/test/compile-fail/issue-2937.rs index 56f0c5e3dd0..b225c5496e2 100644 --- a/src/test/compile-fail/issue-2937.rs +++ b/src/test/compile-fail/issue-2937.rs @@ -9,6 +9,7 @@ // except according to those terms. use x = m::f; //~ ERROR failed to resolve import + //~^ ERROR unresolved import: there is no `f` in `m` mod m { } diff --git a/src/test/compile-fail/issue-3993-2.rs b/src/test/compile-fail/issue-3993-2.rs index 1293dc8a875..2ca871cd11c 100644 --- a/src/test/compile-fail/issue-3993-2.rs +++ b/src/test/compile-fail/issue-3993-2.rs @@ -9,6 +9,7 @@ // except according to those terms. use zoo::{duck, goose}; //~ ERROR failed to resolve import + //~^ ERROR unresolved import: found `goose` in `zoo` but it is private mod zoo { pub enum bird { diff --git a/src/test/compile-fail/issue-3993-3.rs b/src/test/compile-fail/issue-3993-3.rs index 1ccf019a7c1..ccda6f158ed 100644 --- a/src/test/compile-fail/issue-3993-3.rs +++ b/src/test/compile-fail/issue-3993-3.rs @@ -9,6 +9,7 @@ // except according to those terms. use zoo::fly; //~ ERROR failed to resolve import + //~^ ERROR unresolved import: found `fly` in `zoo` but it is private mod zoo { priv type fly = (); diff --git a/src/test/compile-fail/issue-3993.rs b/src/test/compile-fail/issue-3993.rs index 5b47c3e2406..450ea023bcb 100644 --- a/src/test/compile-fail/issue-3993.rs +++ b/src/test/compile-fail/issue-3993.rs @@ -9,6 +9,7 @@ // except according to those terms. use zoo::fly; //~ ERROR failed to resolve import + //~^ ERROR unresolved import: found `fly` in `zoo` but it is private mod zoo { priv fn fly() {} diff --git a/src/test/compile-fail/super-at-top-level.rs b/src/test/compile-fail/super-at-top-level.rs index f1064a62905..9ec92e6dbfa 100644 --- a/src/test/compile-fail/super-at-top-level.rs +++ b/src/test/compile-fail/super-at-top-level.rs @@ -1,5 +1,4 @@ -use super::f; //~ ERROR unresolved name -//~^ ERROR failed to resolve import +use super::f; //~ ERROR failed to resolve import fn main() { } diff --git a/src/test/compile-fail/unresolved-import.rs b/src/test/compile-fail/unresolved-import.rs index 1bd3efeadcb..fc69c34c118 100644 --- a/src/test/compile-fail/unresolved-import.rs +++ b/src/test/compile-fail/unresolved-import.rs @@ -8,5 +8,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use foo::bar; //~ ERROR unresolved import. maybe a missing - //~^ ERROR failed to resolve import +use foo::bar; //~ ERROR unresolved import. maybe a missing `extern mod foo`? + //~^ ERROR failed to resolve import `foo::bar` +use x = bar::baz; //~ ERROR unresolved import: there is no `baz` in `bar` + //~^ ERROR failed to resolve import `bar::baz` + +mod bar { + struct bar; +} diff --git a/src/test/compile-fail/unsafe-fn-autoderef.rs b/src/test/compile-fail/unsafe-fn-autoderef.rs index b602d1717be..82efd579518 100644 --- a/src/test/compile-fail/unsafe-fn-autoderef.rs +++ b/src/test/compile-fail/unsafe-fn-autoderef.rs @@ -9,9 +9,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// xfail-test -type rec = {f: int}; -fn f(p: *rec) -> int { +struct Rec { + f: int +} + +fn f(p: *Rec) -> int { // Test that * ptrs do not autoderef. There is a deeper reason for // prohibiting this, beyond making unsafe things annoying (which doesn't @@ -25,7 +27,7 @@ fn f(p: *rec) -> int { // are prohibited by various checks, such as that the enum is // instantiable and so forth). - return p.f; //~ ERROR attempted access of field `f` on type `*rec` + return p.f; //~ ERROR attempted access of field `f` on type `*Rec` } fn main() { diff --git a/src/test/run-pass/assignability-trait.rs b/src/test/run-pass/assignability-trait.rs index 6946ed3fbcf..b21213bb221 100644 --- a/src/test/run-pass/assignability-trait.rs +++ b/src/test/run-pass/assignability-trait.rs @@ -39,15 +39,15 @@ pub fn main() { // Call a method for x.iterate() |y| { assert!(x[*y] == *y); } // Call a parameterized function - assert!(length(x.clone()) == vec::len(x)); + assert!(length(x.clone()) == x.len()); // Call a parameterized function, with type arguments that require // a borrow - assert!(length::<int, &[int]>(x) == vec::len(x)); + assert!(length::<int, &[int]>(x) == x.len()); // Now try it with a type that *needs* to be borrowed let z = [0,1,2,3]; // Call a method for z.iterate() |y| { assert!(z[*y] == *y); } // Call a parameterized function - assert!(length::<int, &[int]>(z) == vec::len(z)); + assert!(length::<int, &[int]>(z) == z.len()); } diff --git a/src/test/run-pass/class-implements-multiple-traits.rs b/src/test/run-pass/class-implements-multiple-traits.rs index 3a5bd648639..61dfcfed7bd 100644 --- a/src/test/run-pass/class-implements-multiple-traits.rs +++ b/src/test/run-pass/class-implements-multiple-traits.rs @@ -103,7 +103,7 @@ fn annoy_neighbors<T:noisy>(critter: T) { fn bite_everything<T:bitey>(critter: T) -> bool { let mut left : ~[body_part] = ~[finger, toe, nose, ear]; - while vec::len(left) > 0u { + while left.len() > 0u { let part = critter.bite(); debug!("%? %?", left, part); if vec_includes(left, part) { diff --git a/src/test/run-pass/cond-macro-no-default.rs b/src/test/run-pass/cond-macro-no-default.rs new file mode 100644 index 00000000000..6b90308f8a8 --- /dev/null +++ b/src/test/run-pass/cond-macro-no-default.rs @@ -0,0 +1,23 @@ +// Copyright 2013 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. + +fn clamp<T:Copy + Ord + Signed>(x: T, mn: T, mx: T) -> T { + cond!( + (x > mx) { return mx; } + (x < mn) { return mn; } + ) + return x; +} + +fn main() { + assert_eq!(clamp(1, 2, 4), 2); + assert_eq!(clamp(8, 2, 4), 4); + assert_eq!(clamp(3, 2, 4), 3); +} diff --git a/src/test/run-pass/cond-macro.rs b/src/test/run-pass/cond-macro.rs new file mode 100644 index 00000000000..929752b3f1a --- /dev/null +++ b/src/test/run-pass/cond-macro.rs @@ -0,0 +1,23 @@ +// Copyright 2013 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. + +fn clamp<T:Copy + Ord + Signed>(x: T, mn: T, mx: T) -> T { + cond!( + (x > mx) { mx } + (x < mn) { mn } + _ { x } + ) +} + +fn main() { + assert_eq!(clamp(1, 2, 4), 2); + assert_eq!(clamp(8, 2, 4), 4); + assert_eq!(clamp(3, 2, 4), 3); +} diff --git a/src/test/run-pass/hashmap-memory.rs b/src/test/run-pass/hashmap-memory.rs index bca4cbafc6c..c6ae2047147 100644 --- a/src/test/run-pass/hashmap-memory.rs +++ b/src/test/run-pass/hashmap-memory.rs @@ -71,7 +71,7 @@ mod map_reduce { start_mappers(ctrl_chan, inputs.clone()); - let mut num_mappers = vec::len(inputs) as int; + let mut num_mappers = inputs.len() as int; while num_mappers > 0 { match ctrl_port.recv() { diff --git a/src/test/run-pass/vec-self-append.rs b/src/test/run-pass/vec-self-append.rs index acd9cf6f01b..7507a78378e 100644 --- a/src/test/run-pass/vec-self-append.rs +++ b/src/test/run-pass/vec-self-append.rs @@ -14,7 +14,7 @@ fn test_heap_to_heap() { // a spills onto the heap let mut a = ~[0, 1, 2, 3, 4]; a = a + a; // FIXME(#3387)---can't write a += a - assert!((vec::len(a) == 10u)); + assert!(a.len() == 10u); assert!((a[0] == 0)); assert!((a[1] == 1)); assert!((a[2] == 2)); @@ -32,7 +32,7 @@ fn test_stack_to_heap() { let mut a = ~[0, 1, 2]; // a spills to the heap a = a + a; // FIXME(#3387)---can't write a += a - assert!((vec::len(a) == 6u)); + assert!(a.len() == 6u); assert!((a[0] == 0)); assert!((a[1] == 1)); assert!((a[2] == 2)); @@ -47,8 +47,8 @@ fn test_loop() { let mut i = 20; let mut expected_len = 1u; while i > 0 { - error!(vec::len(a)); - assert!((vec::len(a) == expected_len)); + error!(a.len()); + assert!(a.len() == expected_len); a = a + a; // FIXME(#3387)---can't write a += a i -= 1; expected_len *= 2u; |