Rename last to last_opt, last_unsafe to last

As per discussion on IRC. I am about to file an RFC for further
discussion about the more general issue of whether to enforce
invariants through types, typestate, or dynamic checks, but for now,
removing the misleading name "last_unsafe".

13 files changed, 27 insertions, 28 deletions

diff --git a/src/libcore/path.rs b/src/libcore/path.rs
index 1cfafd25740..5658e57f68a 100644
--- a/src/libcore/path.rs
+++ b/src/libcore/path.rs
@@ -170,7 +170,7 @@ fn splitext(p: path) -> (str, str) {
         if vec::len(parts) > 1u {
             let base = str::connect(vec::init(parts), ".");
             // We just checked that parts is non-empty, so this is safe
-            let ext = "." + vec::last_unsafe(parts);
+            let ext = "." + vec::last(parts);
 
             fn is_dotfile(base: str) -> bool {
                 str::is_empty(base)
diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs
index 3737f9bac1d..f1aac380886 100644
--- a/src/libcore/vec.rs
+++ b/src/libcore/vec.rs
@@ -187,27 +187,24 @@ fn init<T: copy>(v: [const T]) -> [T] {
 /*
 Function: last
 
-Returns the last element of a vector
-
-Returns:
+Returns the last element of a `v`, failing if the vector is empty.
 
-An option containing the last element of `v` if `v` is not empty, or
-none if `v` is empty.
 */
-pure fn last<T: copy>(v: [const T]) -> option<T> {
-    if len(v) == 0u { ret none; }
-    ret some(v[len(v) - 1u]);
+pure fn last<T: copy>(v: [const T]) -> T {
+    if len(v) == 0u { fail "last_unsafe: empty vector" }
+    v[len(v) - 1u]
 }
 
 /*
-Function: last_unsafe
+Function: last_opt
 
-Returns the last element of a `v`, failing if the vector is empty.
+Returns some(x) where `x` is the last element of a vector `v`,
+or none if the vector is empty.
 
 */
-pure fn last_unsafe<T: copy>(v: [const T]) -> T {
-    if len(v) == 0u { fail "last_unsafe: empty vector" }
-    v[len(v) - 1u]
+pure fn last_opt<T: copy>(v: [const T]) -> option<T> {
+    if len(v) == 0u { ret none; }
+    some(v[len(v) - 1u])
 }
 
 /*
@@ -1270,11 +1267,11 @@ mod tests {
 
     #[test]
     fn test_last() {
-        let n = last([]);
+        let n = last_opt([]);
         assert (n == none);
-        n = last([1, 2, 3]);
+        n = last_opt([1, 2, 3]);
         assert (n == some(3));
-        n = last([1, 2, 3, 4, 5]);
+        n = last_opt([1, 2, 3, 4, 5]);
         assert (n == some(5));
     }
 
diff --git a/src/libstd/fs.rs b/src/libstd/fs.rs
index 6627b0fec21..8a5b88f7480 100644
--- a/src/libstd/fs.rs
+++ b/src/libstd/fs.rs
@@ -271,7 +271,7 @@ fn splitext(p: path) -> (str, str) {
         if vec::len(parts) > 1u {
             let base = str::connect(vec::init(parts), ".");
             // We just checked that parts is non-empty
-            let ext = "." + vec::last_unsafe(parts);
+            let ext = "." + vec::last(parts);
 
             fn is_dotfile(base: str) -> bool {
                 str::is_empty(base)
diff --git a/src/rustc/front/attr.rs b/src/rustc/front/attr.rs
index 834d0957ca5..fc9c50a1e00 100644
--- a/src/rustc/front/attr.rs
+++ b/src/rustc/front/attr.rs
@@ -256,7 +256,7 @@ fn meta_item_from_list(
     name: str
 ) -> option<@ast::meta_item> {
     let items = attr::find_meta_items_by_name(items, name);
-    vec::last(items)
+    vec::last_opt(items)
 }
 
 fn meta_item_value_from_list(
diff --git a/src/rustc/metadata/creader.rs b/src/rustc/metadata/creader.rs
index cfa16a38b4f..986c42ca7c2 100644
--- a/src/rustc/metadata/creader.rs
+++ b/src/rustc/metadata/creader.rs
@@ -144,7 +144,7 @@ fn find_library_crate(sess: session::session, ident: ast::ident,
     let crate_name =
         {
             let name_items = attr::find_meta_items_by_name(metas, "name");
-            alt vec::last(name_items) {
+            alt vec::last_opt(name_items) {
               some(i) {
                 alt attr::get_meta_item_value_str(i) {
                   some(n) { n }
diff --git a/src/rustc/middle/ast_map.rs b/src/rustc/middle/ast_map.rs
index 72a89feedd9..e64ee524b4d 100644
--- a/src/rustc/middle/ast_map.rs
+++ b/src/rustc/middle/ast_map.rs
@@ -189,7 +189,7 @@ fn map_view_item(vi: @view_item, cx: ctx, _v: vt) {
               view_path_glob(pth, id) | view_path_list(pth, _, id) {
                   // should be a constraint on the type
                 assert (vec::is_not_empty(*pth));
-                (id, vec::last_unsafe(*pth))
+                (id, vec::last(*pth))
               }
             };
             cx.map.insert(id, node_export(vp, extend(cx, name)));
diff --git a/src/rustc/middle/pat_util.rs b/src/rustc/middle/pat_util.rs
index bc98c621a34..4327acdb058 100644
--- a/src/rustc/middle/pat_util.rs
+++ b/src/rustc/middle/pat_util.rs
@@ -70,5 +70,5 @@ fn pat_binding_ids(dm: resolve::def_map, pat: @pat) -> [node_id] {
 
 fn path_to_ident(p: @path) -> ident {
   assert (vec::is_not_empty(p.node.idents)); // should be a constraint on path
-  vec::last_unsafe(p.node.idents)
+  vec::last(p.node.idents)
 }
diff --git a/src/rustc/middle/tstate/bitvectors.rs b/src/rustc/middle/tstate/bitvectors.rs
index 7433da333ac..a64b9491824 100644
--- a/src/rustc/middle/tstate/bitvectors.rs
+++ b/src/rustc/middle/tstate/bitvectors.rs
@@ -183,7 +183,7 @@ fn kill_poststate(fcx: fn_ctxt, id: node_id, c: tsconstr) -> bool {
 fn clear_in_poststate_expr(fcx: fn_ctxt, e: @expr, t: poststate) {
     alt e.node {
       expr_path(p) {
-        alt vec::last(p.node.idents) {
+        alt vec::last_opt(p.node.idents) {
           some(i) {
             alt local_node_id_to_def(fcx, e.id) {
               some(def_local(nid, _)) {
diff --git a/src/rustc/middle/tstate/states.rs b/src/rustc/middle/tstate/states.rs
index c7eebf317af..1c997ca84e8 100644
--- a/src/rustc/middle/tstate/states.rs
+++ b/src/rustc/middle/tstate/states.rs
@@ -406,7 +406,7 @@ fn find_pre_post_state_expr(fcx: fn_ctxt, pres: prestate, e: @expr) -> bool {
                                                     init_assign),
                                       exs, return_val);
 
-        let base_pres = alt vec::last(exs) { none { pres }
+        let base_pres = alt vec::last_opt(exs) { none { pres }
                           some(f) { expr_poststate(fcx.ccx, f) }};
         option::may(maybe_base, {|base|
             changed |= find_pre_post_state_expr(fcx, base_pres, base) |
diff --git a/src/rustc/middle/typeck.rs b/src/rustc/middle/typeck.rs
index 85dbedaefcc..d690bcb4d9d 100644
--- a/src/rustc/middle/typeck.rs
+++ b/src/rustc/middle/typeck.rs
@@ -2642,7 +2642,7 @@ fn bind_params(fcx: @fn_ctxt, tp: ty::t, count: uint)
 }
 
 fn get_self_info(ccx: @crate_ctxt) -> option<self_info> {
-    ret vec::last(ccx.self_infos);
+    ret vec::last_opt(ccx.self_infos);
 }
 
 fn check_decl_initializer(fcx: @fn_ctxt, nid: ast::node_id,
diff --git a/src/rustc/util/common.rs b/src/rustc/util/common.rs
index 87a1f6145d6..cd45deb9423 100644
--- a/src/rustc/util/common.rs
+++ b/src/rustc/util/common.rs
@@ -89,7 +89,9 @@ fn local_rhs_span(l: @ast::local, def: span) -> span {
 }
 
 fn is_main_name(path: middle::ast_map::path) -> bool {
-    option::get(vec::last(path)) == middle::ast_map::path_name("main")
+    // FIXME: path should be a constrained type, so we know
+    // the call to last doesn't fail
+    vec::last(path) == middle::ast_map::path_name("main")
 }
 
 //
diff --git a/src/rustdoc/reexport_pass.rs b/src/rustdoc/reexport_pass.rs
index 02ffa3337b4..978c6fc9014 100644
--- a/src/rustdoc/reexport_pass.rs
+++ b/src/rustdoc/reexport_pass.rs
@@ -163,7 +163,7 @@ fn build_reexport_path_map(srv: astsrv::srv, -def_map: def_map) -> path_map {
             };
           // should be a constraint on the node_export constructor
           // that guarantees path is non-empty
-            let name = alt check vec::last_unsafe(*path) {
+            let name = alt check vec::last(*path) {
               ast_map::path_name(nm) { nm }
             };
             let modpath = ast_map::path_to_str(vec::init(*path));
diff --git a/src/test/run-pass/zip-same-length.rs b/src/test/run-pass/zip-same-length.rs
index 787fd3e1c1e..813548dc35e 100644
--- a/src/test/run-pass/zip-same-length.rs
+++ b/src/test/run-pass/zip-same-length.rs
@@ -19,5 +19,5 @@ fn main() {
 
     check (is_not_empty(ps));
     assert (head(ps) == ('a', 1u));
-    assert (last_unsafe(ps) == (j as char, 10u));
+    assert (last(ps) == (j as char, 10u));
 }