---

yaml
---
r: 141006
b: refs/heads/try2
c: 0d1331f
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: d951da82768685cacba7444dae10ede2a71efedb
+refs/heads/try2: 0d1331f4a0cade66349a4c22315899210ad9b6a7
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/.gitignore

@@ -39,6 +39,7 @@
 *.diff
 *.rej
 *.swp
+*.swo
 *.tmp
 *.pyc
 *.elc

branches/try2/.swo

@@ -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

branches/try2/doc/tutorial-borrowed-ptr.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();

branches/try2/doc/tutorial.md

@@ -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",

branches/try2/src/compiletest/runtest.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);
 }

branches/try2/src/libcore/either.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));
             }
         }

branches/try2/src/libcore/io.rs

@@ -412,7 +412,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)
             }
@@ -1492,7 +1492,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);
@@ -1583,7 +1583,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);

branches/try2/src/libcore/os.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];

branches/try2/src/libcore/ptr.rs

@@ -230,7 +230,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 {