Change option::t to option

Now that core exports "option" as a synonym for option::t, search-and-
replace option::t with option.

The only place that still refers to option::t are the modules in libcore
that use option, because fixing this requires a new snapshot
(forthcoming).

Author: catamorphism

src/cargo/cargo.rs

@@ -32,16 +32,16 @@ type package = {
     url: str,
     method: str,
     description: str,
-    ref: option::t<str>,
+    ref: option<str>,
     tags: [str]
 };
 
 type source = {
     name: str,
     url: str,
-    sig: option::t<str>,
-    key: option::t<str>,
-    keyfp: option::t<str>,
+    sig: option<str>,
+    key: option<str>,
+    keyfp: option<str>,
     mutable packages: [package]
 };
 
@@ -60,9 +60,9 @@ type pkg = {
     name: str,
     vers: str,
     uuid: str,
-    desc: option::t<str>,
-    sigs: option::t<str>,
-    crate_type: option::t<str>
+    desc: option<str>,
+    sigs: option<str>,
+    crate_type: option<str>
 };
 
 fn info(msg: str) {
@@ -77,9 +77,9 @@ fn error(msg: str) {
     io::stdout().write_line("error: " + msg);
 }
 
-fn load_link(mis: [@ast::meta_item]) -> (option::t<str>,
-                                         option::t<str>,
-                                         option::t<str>) {
+fn load_link(mis: [@ast::meta_item]) -> (option<str>,
+                                         option<str>,
+                                         option<str>) {
     let name = none;
     let vers = none;
     let uuid = none;
@@ -99,7 +99,7 @@ fn load_link(mis: [@ast::meta_item]) -> (option::t<str>,
     (name, vers, uuid)
 }
 
-fn load_pkg(filename: str) -> option::t<pkg> {
+fn load_pkg(filename: str) -> option<pkg> {
     let cm = codemap::new_codemap();
     let handler = diagnostic::mk_handler(none);
     let sess = @{
@@ -439,7 +439,7 @@ fn install_source(c: cargo, path: str) {
     }
 }
 
-fn install_git(c: cargo, wd: str, url: str, ref: option::t<str>) {
+fn install_git(c: cargo, wd: str, url: str, ref: option<str>) {
     run::run_program("git", ["clone", url, wd]);
     if option::is_some::<str>(ref) {
         let r = option::get::<str>(ref);

src/comp/back/link.rs

@@ -38,7 +38,7 @@ fn llvm_err(sess: session, msg: str) unsafe {
     } else { sess.fatal(msg + ": " + str::from_cstr(buf)); }
 }
 
-fn load_intrinsics_bc(sess: session) -> option::t<ModuleRef> {
+fn load_intrinsics_bc(sess: session) -> option<ModuleRef> {
     let path = alt filesearch::search(
         sess.filesearch,
         bind filesearch::pick_file("intrinsics.bc", _)) {
@@ -368,14 +368,14 @@ fn build_link_meta(sess: session, c: ast::crate, output: str,
                    sha: sha1) -> link_meta {
 
     type provided_metas =
-        {name: option::t<str>,
-         vers: option::t<str>,
+        {name: option<str>,
+         vers: option<str>,
          cmh_items: [@ast::meta_item]};
 
     fn provided_link_metas(sess: session, c: ast::crate) ->
        provided_metas {
-        let name: option::t<str> = none;
-        let vers: option::t<str> = none;
+        let name: option<str> = none;
+        let vers: option<str> = none;
         let cmh_items: [@ast::meta_item] = [];
         let linkage_metas = attr::find_linkage_metas(c.node.attrs);
         attr::require_unique_names(sess, linkage_metas);

src/comp/driver/driver.rs

@@ -105,8 +105,8 @@ enum compile_upto {
 
 fn compile_upto(sess: session, cfg: ast::crate_cfg,
                 input: str, upto: compile_upto,
-                outputs: option::t<output_filenames>)
-    -> {crate: @ast::crate, tcx: option::t<ty::ctxt>} {
+                outputs: option<output_filenames>)
+    -> {crate: @ast::crate, tcx: option<ty::ctxt>} {
     let time_passes = sess.opts.time_passes;
     let crate = time(time_passes, "parsing",
                      bind parse_input(sess, cfg, input));
@@ -197,7 +197,7 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg,
 }
 
 fn compile_input(sess: session, cfg: ast::crate_cfg, input: str,
-                 outdir: option::t<str>, output: option::t<str>) {
+                 outdir: option<str>, output: option<str>) {
 
     let upto = if sess.opts.parse_only { cu_parse }
                else if sess.opts.no_trans { cu_no_trans }
@@ -504,8 +504,8 @@ fn opts() -> [getopts::opt] {
 type output_filenames = @{out_filename: str, obj_filename:str};
 
 fn build_output_filenames(ifile: str,
-                          odir: option::t<str>,
-                          ofile: option::t<str>,
+                          odir: option<str>,
+                          ofile: option<str>,
                           sess: session)
         -> output_filenames {
     let obj_path = "";

src/comp/driver/session.rs

@@ -40,7 +40,7 @@ type options =
      time_llvm_passes: bool,
      output_type: back::link::output_type,
      addl_lib_search_paths: [str],
-     maybe_sysroot: option::t<str>,
+     maybe_sysroot: option<str>,
      target_triple: str,
      cfg: ast::crate_cfg,
      test: bool,
@@ -58,7 +58,7 @@ type session = @{targ_cfg: @config,
                  parse_sess: parse_sess,
                  codemap: codemap::codemap,
                  // For a library crate, this is always none
-                 mutable main_fn: option::t<(node_id, codemap::span)>,
+                 mutable main_fn: option<(node_id, codemap::span)>,
                  span_diagnostic: diagnostic::span_handler,
                  filesearch: filesearch::filesearch,
                  mutable building_library: bool,

src/comp/front/attr.rs

@@ -48,7 +48,7 @@ fn find_linkage_metas(attrs: [ast::attribute]) -> [@ast::meta_item] {
 fn find_attrs_by_name(attrs: [ast::attribute], name: ast::ident) ->
    [ast::attribute] {
     let filter = (
-        fn@(a: ast::attribute) -> option::t<ast::attribute> {
+        fn@(a: ast::attribute) -> option<ast::attribute> {
             if get_attr_name(a) == name {
                 option::some(a)
             } else { option::none }
@@ -67,7 +67,7 @@ fn get_attr_name(attr: ast::attribute) -> ast::ident {
 
 fn find_meta_items_by_name(metas: [@ast::meta_item], name: ast::ident) ->
    [@ast::meta_item] {
-    let filter = fn@(&&m: @ast::meta_item) -> option::t<@ast::meta_item> {
+    let filter = fn@(&&m: @ast::meta_item) -> option<@ast::meta_item> {
         if get_meta_item_name(m) == name {
             option::some(m)
         } else { option::none }
@@ -85,7 +85,7 @@ fn get_meta_item_name(meta: @ast::meta_item) -> ast::ident {
 
 // Gets the string value if the meta_item is a meta_name_value variant
 // containing a string, otherwise none
-fn get_meta_item_value_str(meta: @ast::meta_item) -> option::t<str> {
+fn get_meta_item_value_str(meta: @ast::meta_item) -> option<str> {
     alt meta.node {
       ast::meta_name_value(_, v) {
         alt v.node { ast::lit_str(s) { option::some(s) } _ { option::none } }
@@ -95,15 +95,15 @@ fn get_meta_item_value_str(meta: @ast::meta_item) -> option::t<str> {
 }
 
 fn get_meta_item_value_str_by_name(attrs: [ast::attribute], name: ast::ident)
-    -> option::t<str> {
+    -> option<str> {
     let mattrs = find_attrs_by_name(attrs, name);
     if vec::len(mattrs) > 0u {
         ret get_meta_item_value_str(attr_meta(mattrs[0]));
     }
     ret option::none;
 }
 
-fn get_meta_item_list(meta: @ast::meta_item) -> option::t<[@ast::meta_item]> {
+fn get_meta_item_list(meta: @ast::meta_item) -> option<[@ast::meta_item]> {
     alt meta.node {
       ast::meta_list(_, l) { option::some(l) }
       _ { option::none }
@@ -184,7 +184,7 @@ fn sort_meta_items(items: [@ast::meta_item]) -> [@ast::meta_item] {
 fn remove_meta_items_by_name(items: [@ast::meta_item], name: str) ->
    [@ast::meta_item] {
 
-    let filter = fn@(&&item: @ast::meta_item) -> option::t<@ast::meta_item> {
+    let filter = fn@(&&item: @ast::meta_item) -> option<@ast::meta_item> {
         if get_meta_item_name(item) != name {
             option::some(item)
         } else { option::none }

src/comp/front/config.rs

@@ -37,7 +37,7 @@ fn strip_items(crate: @ast::crate, in_cfg: in_cfg_pred)
 }
 
 fn filter_item(cx: ctxt, &&item: @ast::item) ->
-   option::t<@ast::item> {
+   option<@ast::item> {
     if item_in_cfg(cx, item) { option::some(item) } else { option::none }
 }
 
@@ -50,7 +50,7 @@ fn fold_mod(cx: ctxt, m: ast::_mod, fld: fold::ast_fold) ->
 }
 
 fn filter_native_item(cx: ctxt, &&item: @ast::native_item) ->
-   option::t<@ast::native_item> {
+   option<@ast::native_item> {
     if native_item_in_cfg(cx, item) {
         option::some(item)
     } else { option::none }
@@ -65,7 +65,7 @@ fn fold_native_mod(cx: ctxt, nm: ast::native_mod,
 }
 
 fn filter_stmt(cx: ctxt, &&stmt: @ast::stmt) ->
-   option::t<@ast::stmt> {
+   option<@ast::stmt> {
     alt stmt.node {
       ast::stmt_decl(decl, _) {
         alt decl.node {

src/comp/front/test.rs

@@ -67,7 +67,7 @@ fn fold_mod(_cx: test_ctxt, m: ast::_mod, fld: fold::ast_fold) -> ast::_mod {
     // the one we're going to add.  FIXME: This is sloppy. Instead we should
     // have some mechanism to indicate to the translation pass which function
     // we want to be main.
-    fn nomain(&&item: @ast::item) -> option::t<@ast::item> {
+    fn nomain(&&item: @ast::item) -> option<@ast::item> {
         alt item.node {
           ast::item_fn(_, _, _) {
             if item.ident == "main" {

src/comp/lib/llvm.rs

@@ -917,11 +917,11 @@ fn associate_type(tn: type_names, s: str, t: TypeRef) {
     assert tn.named_types.insert(s, t);
 }
 
-fn type_has_name(tn: type_names, t: TypeRef) -> option::t<str> {
+fn type_has_name(tn: type_names, t: TypeRef) -> option<str> {
     ret tn.type_names.find(t);
 }
 
-fn name_has_type(tn: type_names, s: str) -> option::t<TypeRef> {
+fn name_has_type(tn: type_names, s: str) -> option<TypeRef> {
     ret tn.named_types.find(s);
 }
 
@@ -1072,7 +1072,7 @@ resource object_file_res(ObjectFile: ObjectFileRef) {
 
 type object_file = {llof: ObjectFileRef, dtor: @object_file_res};
 
-fn mk_object_file(llmb: MemoryBufferRef) -> option::t<object_file> {
+fn mk_object_file(llmb: MemoryBufferRef) -> option<object_file> {
     let llof = llvm::LLVMCreateObjectFile(llmb);
     if llof as int == 0 { ret option::none::<object_file>; }
     ret option::some({llof: llof, dtor: @object_file_res(llof)});

src/comp/metadata/creader.rs

@@ -137,7 +137,7 @@ fn default_native_lib_naming(sess: session::session, static: bool) ->
 
 fn find_library_crate(sess: session::session, ident: ast::ident,
                       metas: [@ast::meta_item])
-   -> option::t<{ident: str, data: @[u8]}> {
+   -> option<{ident: str, data: @[u8]}> {
 
     attr::require_unique_names(sess, metas);
     let metas = metas;
@@ -173,7 +173,7 @@ fn find_library_crate_aux(sess: session::session,
                           crate_name: str,
                           metas: [@ast::meta_item],
                           filesearch: filesearch::filesearch) ->
-   option::t<{ident: str, data: @[u8]}> {
+   option<{ident: str, data: @[u8]}> {
     let prefix: str = nn.prefix + crate_name + "-";
     let suffix: str = nn.suffix;
 
@@ -206,7 +206,7 @@ fn find_library_crate_aux(sess: session::session,
 }
 
 fn get_metadata_section(sess: session::session,
-                        filename: str) -> option::t<@[u8]> unsafe {
+                        filename: str) -> option<@[u8]> unsafe {
     let mb = str::as_buf(filename, {|buf|
         llvm::LLVMRustCreateMemoryBufferWithContentsOfFile(buf)
                                    });

src/comp/metadata/csearch.rs

@@ -63,7 +63,7 @@ fn get_enum_variants(tcx: ty::ctxt, def: ast::def_id) -> [ty::variant_info] {
 }
 
 fn get_impls_for_mod(cstore: cstore::cstore, def: ast::def_id,
-                     name: option::t<ast::ident>)
+                     name: option<ast::ident>)
     -> @[@middle::resolve::_impl] {
     let cdata = cstore::get_crate_data(cstore, def.crate);
     decoder::get_impls_for_mod(cdata, def.node, name)
@@ -82,7 +82,7 @@ fn get_type(tcx: ty::ctxt, def: ast::def_id) -> ty::ty_param_bounds_and_ty {
 }
 
 fn get_impl_iface(tcx: ty::ctxt, def: ast::def_id)
-    -> option::t<ty::t> {
+    -> option<ty::t> {
     let cstore = tcx.sess.cstore;
     let cdata = cstore::get_crate_data(cstore, def.crate);
     decoder::get_impl_iface(cdata, def.node, tcx)

src/comp/metadata/decoder.rs

@@ -55,7 +55,7 @@ fn lookup_hash(d: ebml::doc, eq_fn: fn@([u8]) -> bool, hash: uint) ->
     ret result;
 }
 
-fn maybe_find_item(item_id: int, items: ebml::doc) -> option::t<ebml::doc> {
+fn maybe_find_item(item_id: int, items: ebml::doc) -> option<ebml::doc> {
     fn eq_item(bytes: [u8], item_id: int) -> bool {
         ret ebml::be_uint_from_bytes(@bytes, 0u, 4u) as int == item_id;
     }
@@ -92,7 +92,7 @@ fn variant_enum_id(d: ebml::doc) -> ast::def_id {
     ret parse_def_id(ebml::doc_data(tagdoc));
 }
 
-fn variant_disr_val(d: ebml::doc) -> option::t<int> {
+fn variant_disr_val(d: ebml::doc) -> option<int> {
     alt ebml::maybe_get_doc(d, tag_disr_val) {
       some(val_doc) {
         let val_buf = ebml::doc_data(val_doc);
@@ -118,7 +118,7 @@ fn item_type(item: ebml::doc, tcx: ty::ctxt, cdata: cmd) -> ty::t {
 }
 
 fn item_impl_iface(item: ebml::doc, tcx: ty::ctxt, cdata: cmd)
-    -> option::t<ty::t> {
+    -> option<ty::t> {
     let result = none;
     ebml::tagged_docs(item, tag_impl_iface) {|ity|
         let t = parse_ty_data(ity.data, cdata.cnum, ity.start, tcx, {|did|
@@ -227,7 +227,7 @@ fn get_type_param_count(data: @[u8], id: ast::node_id) -> uint {
 }
 
 fn get_impl_iface(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
-    -> option::t<ty::t> {
+    -> option<ty::t> {
     item_impl_iface(lookup_item(id, cdata.data), tcx, cdata)
 }
 
@@ -279,7 +279,7 @@ fn item_impl_methods(cdata: cmd, item: ebml::doc, base_tps: uint)
 }
 
 fn get_impls_for_mod(cdata: cmd, m_id: ast::node_id,
-                     name: option::t<ast::ident>)
+                     name: option<ast::ident>)
     -> @[@middle::resolve::_impl] {
     let data = cdata.data;
     let mod_item = lookup_item(m_id, data), result = [];