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).

15 files changed, 66 insertions, 66 deletions

diff --git a/src/comp/syntax/ast.rs b/src/comp/syntax/ast.rs
index f52afc0875c..38986ea9d64 100644
--- a/src/comp/syntax/ast.rs
+++ b/src/comp/syntax/ast.rs
@@ -8,7 +8,7 @@ type spanned<T> = {node: T, span: span};
 type ident = str;
 
 // Functions may or may not have names.
-type fn_ident = option::t<ident>;
+type fn_ident = option<ident>;
 
 // FIXME: with typestate constraint, could say
 // idents and types are the same length, and are
@@ -87,7 +87,7 @@ enum meta_item_ {
 
 type blk = spanned<blk_>;
 
-type blk_ = {view_items: [@view_item], stmts: [@stmt], expr: option::t<@expr>,
+type blk_ = {view_items: [@view_item], stmts: [@stmt], expr: option<@expr>,
              id: node_id, rules: blk_check_mode};
 
 type pat = {id: node_id, node: pat_, span: span};
@@ -106,7 +106,7 @@ enum pat_ {
     // After the resolution phase, code should never pattern-
     // match on a pat directly! Always call pat_util::normalize_pat --
     // it turns any pat_idents that refer to nullary enums into pat_enums.
-    pat_ident(@path, option::t<@pat>),
+    pat_ident(@path, option<@pat>),
     pat_enum(@path, [@pat]),
     pat_rec([field_pat], bool),
     pat_tup([@pat]),
@@ -180,7 +180,7 @@ enum init_op { init_assign, init_move, }
 type initializer = {op: init_op, expr: @expr};
 
 type local_ =  // FIXME: should really be a refinement on pat
-    {ty: @ty, pat: @pat, init: option::t<initializer>, id: node_id};
+    {ty: @ty, pat: @pat, init: option<initializer>, id: node_id};
 
 type local = spanned<local_>;
 
@@ -190,7 +190,7 @@ enum let_style { let_copy, let_ref, }
 
 enum decl_ { decl_local([(let_style, @local)]), decl_item(@item), }
 
-type arm = {pats: [@pat], guard: option::t<@expr>, body: blk};
+type arm = {pats: [@pat], guard: option<@expr>, body: blk};
 
 type field_ = {mut: mutability, ident: ident, expr: @expr};
 
@@ -204,15 +204,15 @@ type expr = {id: node_id, node: expr_, span: span};
 
 enum expr_ {
     expr_vec([@expr], mutability),
-    expr_rec([field], option::t<@expr>),
+    expr_rec([field], option<@expr>),
     expr_call(@expr, [@expr], bool),
     expr_tup([@expr]),
-    expr_bind(@expr, [option::t<@expr>]),
+    expr_bind(@expr, [option<@expr>]),
     expr_binary(binop, @expr, @expr),
     expr_unary(unop, @expr),
     expr_lit(@lit),
     expr_cast(@expr, @ty),
-    expr_if(@expr, blk, option::t<@expr>),
+    expr_if(@expr, blk, option<@expr>),
     expr_while(@expr, blk),
     expr_for(@local, @expr, blk),
     expr_do_while(blk, @expr),
@@ -233,10 +233,10 @@ enum expr_ {
     expr_field(@expr, ident, [@ty]),
     expr_index(@expr, @expr),
     expr_path(@path),
-    expr_fail(option::t<@expr>),
+    expr_fail(option<@expr>),
     expr_break,
     expr_cont,
-    expr_ret(option::t<@expr>),
+    expr_ret(option<@expr>),
     expr_be(@expr),
     expr_log(int, @expr, @expr),
 
@@ -248,7 +248,7 @@ enum expr_ {
 
     /* FIXME Would be nice if expr_check desugared
        to expr_if_check. */
-    expr_if_check(@expr, blk, option::t<@expr>),
+    expr_if_check(@expr, blk, option<@expr>),
     expr_mac(mac),
 }
 
@@ -274,7 +274,7 @@ enum blk_sort {
 type mac = spanned<mac_>;
 
 enum mac_ {
-    mac_invoc(@path, @expr, option::t<str>),
+    mac_invoc(@path, @expr, option<str>),
     mac_embed_type(@ty),
     mac_embed_block(blk),
     mac_ellipsis,
@@ -415,7 +415,7 @@ type native_mod =
 type variant_arg = {ty: @ty, id: node_id};
 
 type variant_ = {name: ident, attrs: [attribute], args: [variant_arg],
-                 id: node_id, disr_expr: option::t<@expr>};
+                 id: node_id, disr_expr: option<@expr>};
 
 type variant = spanned<variant_>;
 
@@ -465,7 +465,7 @@ enum item_ {
     item_res(fn_decl /* dtor */, [ty_param], blk,
              node_id /* dtor id */, node_id /* ctor id */),
     item_iface([ty_param], [ty_method]),
-    item_impl([ty_param], option::t<@ty> /* iface */,
+    item_impl([ty_param], option<@ty> /* iface */,
               @ty /* self */, [@method]),
 }
 
diff --git a/src/comp/syntax/ast_util.rs b/src/comp/syntax/ast_util.rs
index baaa3022eb3..2e6be5d27d9 100644
--- a/src/comp/syntax/ast_util.rs
+++ b/src/comp/syntax/ast_util.rs
@@ -203,7 +203,7 @@ fn block_from_expr(e: @expr) -> blk {
     ret {node: blk_, span: e.span};
 }
 
-fn default_block(stmts1: [@stmt], expr1: option::t<@expr>, id1: node_id) ->
+fn default_block(stmts1: [@stmt], expr1: option<@expr>, id1: node_id) ->
    blk_ {
     {view_items: [], stmts: stmts1, expr: expr1, id: id1, rules: default_blk}
 }
@@ -364,7 +364,7 @@ pure fn is_unguarded(&&a: arm) -> bool {
     }
 }
 
-pure fn unguarded_pat(a: arm) -> option::t<[@pat]> {
+pure fn unguarded_pat(a: arm) -> option<[@pat]> {
     if is_unguarded(a) { some(a.pats) } else { none }
 }
 
diff --git a/src/comp/syntax/codemap.rs b/src/comp/syntax/codemap.rs
index 3c7d036d1f2..0b893376bdb 100644
--- a/src/comp/syntax/codemap.rs
+++ b/src/comp/syntax/codemap.rs
@@ -67,7 +67,7 @@ fn lookup_byte_pos(map: codemap, pos: uint) -> loc {
 
 enum opt_span {
 
-    //hack (as opposed to option::t), to make `span` compile
+    //hack (as opposed to option), to make `span` compile
     os_none,
     os_some(@span),
 }
diff --git a/src/comp/syntax/ext/base.rs b/src/comp/syntax/ext/base.rs
index 50ff9932e7e..bfe3e36c0bc 100644
--- a/src/comp/syntax/ext/base.rs
+++ b/src/comp/syntax/ext/base.rs
@@ -6,10 +6,10 @@ import std::map::new_str_hash;
 import codemap;
 
 type syntax_expander =
-    fn@(ext_ctxt, span, @ast::expr, option::t<str>) -> @ast::expr;
+    fn@(ext_ctxt, span, @ast::expr, option<str>) -> @ast::expr;
 type macro_def = {ident: str, ext: syntax_extension};
 type macro_definer =
-    fn@(ext_ctxt, span, @ast::expr, option::t<str>) -> macro_def;
+    fn@(ext_ctxt, span, @ast::expr, option<str>) -> macro_def;
 
 enum syntax_extension {
     normal(syntax_expander),
diff --git a/src/comp/syntax/ext/concat_idents.rs b/src/comp/syntax/ext/concat_idents.rs
index c487a3ecc36..0a9d5b4cf3e 100644
--- a/src/comp/syntax/ext/concat_idents.rs
+++ b/src/comp/syntax/ext/concat_idents.rs
@@ -3,7 +3,7 @@ import base::*;
 import syntax::ast;
 
 fn expand_syntax_ext(cx: ext_ctxt, sp: codemap::span, arg: @ast::expr,
-                     _body: option::t<str>) -> @ast::expr {
+                     _body: option<str>) -> @ast::expr {
     let args: [@ast::expr] =
         alt arg.node {
           ast::expr_vec(elts, _) { elts }
diff --git a/src/comp/syntax/ext/env.rs b/src/comp/syntax/ext/env.rs
index e5d80c3f314..fe464473e03 100644
--- a/src/comp/syntax/ext/env.rs
+++ b/src/comp/syntax/ext/env.rs
@@ -10,7 +10,7 @@ import base::*;
 export expand_syntax_ext;
 
 fn expand_syntax_ext(cx: ext_ctxt, sp: codemap::span, arg: @ast::expr,
-                     _body: option::t<str>) -> @ast::expr {
+                     _body: option<str>) -> @ast::expr {
     let args: [@ast::expr] =
         alt arg.node {
           ast::expr_vec(elts, _) { elts }
@@ -22,7 +22,7 @@ fn expand_syntax_ext(cx: ext_ctxt, sp: codemap::span, arg: @ast::expr,
         cx.span_fatal(sp, "malformed #env call");
     }
     // FIXME: if this was more thorough it would manufacture an
-    // option::t<str> rather than just an maybe-empty string.
+    // option<str> rather than just an maybe-empty string.
 
     let var = expr_to_str(cx, args[0], "#env requires a string");
     alt generic_os::getenv(var) {
diff --git a/src/comp/syntax/ext/fmt.rs b/src/comp/syntax/ext/fmt.rs
index 5b57923e308..0dfe2cb17d0 100644
--- a/src/comp/syntax/ext/fmt.rs
+++ b/src/comp/syntax/ext/fmt.rs
@@ -13,7 +13,7 @@ import codemap::span;
 export expand_syntax_ext;
 
 fn expand_syntax_ext(cx: ext_ctxt, sp: span, arg: @ast::expr,
-                     _body: option::t<str>) -> @ast::expr {
+                     _body: option<str>) -> @ast::expr {
     let args: [@ast::expr] =
         alt arg.node {
           ast::expr_vec(elts, _) { elts }
diff --git a/src/comp/syntax/ext/ident_to_str.rs b/src/comp/syntax/ext/ident_to_str.rs
index d6093b61dbf..5fbc05062ee 100644
--- a/src/comp/syntax/ext/ident_to_str.rs
+++ b/src/comp/syntax/ext/ident_to_str.rs
@@ -3,7 +3,7 @@ import base::*;
 import syntax::ast;
 
 fn expand_syntax_ext(cx: ext_ctxt, sp: codemap::span, arg: @ast::expr,
-                     _body: option::t<str>) -> @ast::expr {
+                     _body: option<str>) -> @ast::expr {
     let args: [@ast::expr] =
         alt arg.node {
           ast::expr_vec(elts, _) { elts }
diff --git a/src/comp/syntax/ext/log_syntax.rs b/src/comp/syntax/ext/log_syntax.rs
index 47a639b7ed0..b7be75e349f 100644
--- a/src/comp/syntax/ext/log_syntax.rs
+++ b/src/comp/syntax/ext/log_syntax.rs
@@ -3,7 +3,7 @@ import syntax::ast;
 import std::io::writer_util;
 
 fn expand_syntax_ext(cx: ext_ctxt, sp: codemap::span, arg: @ast::expr,
-                     _body: option::t<str>) -> @ast::expr {
+                     _body: option<str>) -> @ast::expr {
 
     cx.print_backtrace();
     std::io::stdout().write_line(print::pprust::expr_to_str(arg));
diff --git a/src/comp/syntax/ext/simplext.rs b/src/comp/syntax/ext/simplext.rs
index b7fdfc46908..cc133e704e7 100644
--- a/src/comp/syntax/ext/simplext.rs
+++ b/src/comp/syntax/ext/simplext.rs
@@ -15,7 +15,7 @@ import ast::{ident, path, ty, blk_, expr, path_, expr_path,
 
 export add_new_extension;
 
-fn path_to_ident(pth: @path) -> option::t<ident> {
+fn path_to_ident(pth: @path) -> option<ident> {
     if vec::len(pth.node.idents) == 1u && vec::len(pth.node.types) == 0u {
         ret some(pth.node.idents[0u]);
     }
@@ -71,11 +71,11 @@ fn match_error(cx: ext_ctxt, m: matchable, expected: str) -> ! {
 // If we want better match failure error messages (like in Fortifying Syntax),
 // we'll want to return something indicating amount of progress and location
 // of failure instead of `none`.
-type match_result = option::t<arb_depth<matchable>>;
+type match_result = option<arb_depth<matchable>>;
 type selector = fn@(matchable) -> match_result;
 
 fn elts_to_ell(cx: ext_ctxt, elts: [@expr]) ->
-   {pre: [@expr], rep: option::t<@expr>, post: [@expr]} {
+   {pre: [@expr], rep: option<@expr>, post: [@expr]} {
     let idx: uint = 0u;
     let res = none;
     for elt: @expr in elts {
@@ -104,8 +104,8 @@ fn elts_to_ell(cx: ext_ctxt, elts: [@expr]) ->
         }
 }
 
-fn option_flatten_map<T: copy, U: copy>(f: fn@(T) -> option::t<U>, v: [T]) ->
-   option::t<[U]> {
+fn option_flatten_map<T: copy, U: copy>(f: fn@(T) -> option<U>, v: [T]) ->
+   option<[U]> {
     let res = [];
     for elem: T in v {
         alt f(elem) { none { ret none; } some(fv) { res += [fv]; } }
@@ -165,7 +165,7 @@ fn pattern_to_selectors(cx: ext_ctxt, e: @expr) -> binders {
 bindings. Most of the work is done in p_t_s, which generates the
 selectors. */
 
-fn use_selectors_to_bind(b: binders, e: @expr) -> option::t<bindings> {
+fn use_selectors_to_bind(b: binders, e: @expr) -> option<bindings> {
     let res = new_str_hash::<arb_depth<matchable>>();
     //need to do this first, to check vec lengths.
     for sel: selector in b.literal_ast_matchers {
@@ -223,8 +223,8 @@ fn follow(m: arb_depth<matchable>, idx_path: @mutable [uint]) ->
     ret res;
 }
 
-fn follow_for_trans(cx: ext_ctxt, mmaybe: option::t<arb_depth<matchable>>,
-                    idx_path: @mutable [uint]) -> option::t<matchable> {
+fn follow_for_trans(cx: ext_ctxt, mmaybe: option<arb_depth<matchable>>,
+                    idx_path: @mutable [uint]) -> option<matchable> {
     alt mmaybe {
       none { ret none }
       some(m) {
@@ -269,7 +269,7 @@ fn transcribe_exprs(cx: ext_ctxt, b: bindings, idx_path: @mutable [uint],
         alt repeat_me_maybe {
           none { }
           some(repeat_me) {
-            let repeat: option::t<{rep_count: uint, name: ident}> = none;
+            let repeat: option<{rep_count: uint, name: ident}> = none;
             /* we need to walk over all the free vars in lockstep, except for
             the leaves, which are just duplicated */
             free_vars(b, repeat_me) {|fv|
@@ -523,7 +523,7 @@ fn p_t_s_r_path(cx: ext_ctxt, p: @path, s: selector, b: binders) {
     }
 }
 
-fn block_to_ident(blk: blk_) -> option::t<ident> {
+fn block_to_ident(blk: blk_) -> option<ident> {
     if vec::len(blk.stmts) != 0u { ret none; }
     ret alt blk.expr {
           some(expr) {
@@ -667,7 +667,7 @@ fn p_t_s_r_actual_vector(cx: ext_ctxt, elts: [@expr], _repeat_after: bool,
 }
 
 fn add_new_extension(cx: ext_ctxt, sp: span, arg: @expr,
-                     _body: option::t<str>) -> base::macro_def {
+                     _body: option<str>) -> base::macro_def {
     let args: [@ast::expr] =
         alt arg.node {
           ast::expr_vec(elts, _) { elts }
@@ -677,7 +677,7 @@ fn add_new_extension(cx: ext_ctxt, sp: span, arg: @expr,
           }
         };
 
-    let macro_name: option::t<str> = none;
+    let macro_name: option<str> = none;
     let clauses: [@clause] = [];
     for arg: @expr in args {
         alt arg.node {
@@ -751,7 +751,7 @@ fn add_new_extension(cx: ext_ctxt, sp: span, arg: @expr,
          ext: normal(ext)};
 
     fn generic_extension(cx: ext_ctxt, sp: span, arg: @expr,
-                         _body: option::t<str>, clauses: [@clause]) -> @expr {
+                         _body: option<str>, clauses: [@clause]) -> @expr {
         for c: @clause in clauses {
             alt use_selectors_to_bind(c.params, arg) {
               some(bindings) { ret transcribe(cx, bindings, c.body); }
diff --git a/src/comp/syntax/parse/eval.rs b/src/comp/syntax/parse/eval.rs
index 2530c794c94..74d2259c51e 100644
--- a/src/comp/syntax/parse/eval.rs
+++ b/src/comp/syntax/parse/eval.rs
@@ -25,7 +25,7 @@ fn eval_crate_directives(cx: ctx, cdirs: [@ast::crate_directive], prefix: str,
 }
 
 fn eval_crate_directives_to_mod(cx: ctx, cdirs: [@ast::crate_directive],
-                                prefix: str, suffix: option::t<str>)
+                                prefix: str, suffix: option<str>)
     -> (ast::_mod, [ast::attribute]) {
     #debug("eval crate prefix: %s", prefix);
     #debug("eval crate suffix: %s",
@@ -50,10 +50,10 @@ companion mod is a .rs file with the same name as the directory.
 We build the path to the companion mod by combining the prefix and the
 optional suffix then adding the .rs extension.
 */
-fn parse_companion_mod(cx: ctx, prefix: str, suffix: option::t<str>)
+fn parse_companion_mod(cx: ctx, prefix: str, suffix: option<str>)
     -> ([@ast::view_item], [@ast::item], [ast::attribute]) {
 
-    fn companion_file(prefix: str, suffix: option::t<str>) -> str {
+    fn companion_file(prefix: str, suffix: option<str>) -> str {
         ret alt suffix {
           option::some(s) { fs::connect(prefix, s) }
           option::none { prefix }
diff --git a/src/comp/syntax/parse/lexer.rs b/src/comp/syntax/parse/lexer.rs
index ae31f1b3434..03fc4017106 100644
--- a/src/comp/syntax/parse/lexer.rs
+++ b/src/comp/syntax/parse/lexer.rs
@@ -148,7 +148,7 @@ fn consume_block_comment(rdr: reader) {
     be consume_whitespace_and_comments(rdr);
 }
 
-fn scan_exponent(rdr: reader) -> option::t<str> {
+fn scan_exponent(rdr: reader) -> option<str> {
     let c = rdr.curr;
     let rslt = "";
     if c == 'e' || c == 'E' {
diff --git a/src/comp/syntax/parse/parser.rs b/src/comp/syntax/parse/parser.rs
index 95c37b9b8e9..06f4e78372d 100644
--- a/src/comp/syntax/parse/parser.rs
+++ b/src/comp/syntax/parse/parser.rs
@@ -542,7 +542,7 @@ fn parse_fn_block_arg(p: parser) -> ast::arg {
     ret {mode: m, ty: t, ident: i, id: p.get_id()};
 }
 
-fn parse_seq_to_before_gt<T: copy>(sep: option::t<token::token>,
+fn parse_seq_to_before_gt<T: copy>(sep: option<token::token>,
                                   f: fn(parser) -> T,
                                   p: parser) -> [T] {
     let first = true;
@@ -559,7 +559,7 @@ fn parse_seq_to_before_gt<T: copy>(sep: option::t<token::token>,
     ret v;
 }
 
-fn parse_seq_to_gt<T: copy>(sep: option::t<token::token>,
+fn parse_seq_to_gt<T: copy>(sep: option<token::token>,
                            f: fn(parser) -> T, p: parser) -> [T] {
     let v = parse_seq_to_before_gt(sep, f, p);
     expect_gt(p);
@@ -567,7 +567,7 @@ fn parse_seq_to_gt<T: copy>(sep: option::t<token::token>,
     ret v;
 }
 
-fn parse_seq_lt_gt<T: copy>(sep: option::t<token::token>,
+fn parse_seq_lt_gt<T: copy>(sep: option<token::token>,
                            f: fn(parser) -> T,
                            p: parser) -> spanned<[T]> {
     let lo = p.span.lo;
@@ -586,7 +586,7 @@ fn parse_seq_to_end<T: copy>(ket: token::token, sep: seq_sep,
 }
 
 type seq_sep = {
-    sep: option::t<token::token>,
+    sep: option<token::token>,
     trailing_opt: bool   // is trailing separator optional?
 };
 
@@ -845,7 +845,7 @@ fn parse_bottom_expr(p: parser) -> pexpr {
         ret pexpr(mk_mac_expr(p, lo, p.span.hi, ast::mac_ellipsis));
     } else if eat_word(p, "bind") {
         let e = parse_expr_res(p, RESTRICT_NO_CALL_EXPRS);
-        fn parse_expr_opt(p: parser) -> option::t<@ast::expr> {
+        fn parse_expr_opt(p: parser) -> option<@ast::expr> {
             alt p.token {
               token::UNDERSCORE { p.bump(); ret none; }
               _ { ret some(parse_expr(p)); }
@@ -1202,13 +1202,13 @@ fn parse_assign_expr(p: parser) -> @ast::expr {
 fn parse_if_expr_1(p: parser) ->
    {cond: @ast::expr,
     then: ast::blk,
-    els: option::t<@ast::expr>,
+    els: option<@ast::expr>,
     lo: uint,
     hi: uint} {
     let lo = p.last_span.lo;
     let cond = parse_expr(p);
     let thn = parse_block(p);
-    let els: option::t<@ast::expr> = none;
+    let els: option<@ast::expr> = none;
     let hi = thn.span.hi;
     if eat_word(p, "else") {
         let elexpr = parse_else_expr(p);
@@ -1364,7 +1364,7 @@ fn parse_expr_res(p: parser, r: restriction) -> @ast::expr {
     ret e;
 }
 
-fn parse_initializer(p: parser) -> option::t<ast::initializer> {
+fn parse_initializer(p: parser) -> option<ast::initializer> {
     alt p.token {
       token::EQ {
         p.bump();
@@ -2143,7 +2143,7 @@ fn fn_expr_lookahead(tok: token::token) -> bool {
     }
 }
 
-fn parse_item(p: parser, attrs: [ast::attribute]) -> option::t<@ast::item> {
+fn parse_item(p: parser, attrs: [ast::attribute]) -> option<@ast::item> {
     if eat_word(p, "const") {
         ret some(parse_item_const(p, attrs));
     } else if eat_word(p, "inline") {
@@ -2178,7 +2178,7 @@ fn parse_item(p: parser, attrs: [ast::attribute]) -> option::t<@ast::item> {
 
 // A type to distingush between the parsing of item attributes or syntax
 // extensions, which both begin with token.POUND
-type attr_or_ext = option::t<either::t<[ast::attribute], @ast::expr>>;
+type attr_or_ext = option<either::t<[ast::attribute], @ast::expr>>;
 
 fn parse_outer_attrs_or_ext(
     p: parser,
@@ -2292,7 +2292,7 @@ fn parse_use(p: parser) -> ast::view_item_ {
 }
 
 fn parse_rest_import_name(p: parser, first: ast::ident,
-                          def_ident: option::t<ast::ident>) ->
+                          def_ident: option<ast::ident>) ->
    ast::view_item_ {
     let identifiers: [ast::ident] = [first];
     let glob: bool = false;
diff --git a/src/comp/syntax/print/pprust.rs b/src/comp/syntax/print/pprust.rs
index fbfa5f4f433..938e86fc74e 100644
--- a/src/comp/syntax/print/pprust.rs
+++ b/src/comp/syntax/print/pprust.rs
@@ -28,9 +28,9 @@ fn no_ann() -> pp_ann {
 
 type ps =
     @{s: pp::printer,
-      cm: option::t<codemap>,
-      comments: option::t<[lexer::cmnt]>,
-      literals: option::t<[lexer::lit]>,
+      cm: option<codemap>,
+      comments: option<[lexer::cmnt]>,
+      literals: option<[lexer::lit]>,
       mutable cur_cmnt: uint,
       mutable cur_lit: uint,
       mutable boxes: [pp::breaks],
@@ -688,13 +688,13 @@ fn print_maybe_parens_discrim(s: ps, e: @ast::expr) {
 }
 
 fn print_if(s: ps, test: @ast::expr, blk: ast::blk,
-            elseopt: option::t<@ast::expr>, chk: bool) {
+            elseopt: option<@ast::expr>, chk: bool) {
     head(s, "if");
     if chk { word_nbsp(s, "check"); }
     print_maybe_parens_discrim(s, test);
     space(s.s);
     print_block(s, blk);
-    fn do_else(s: ps, els: option::t<@ast::expr>) {
+    fn do_else(s: ps, els: option<@ast::expr>) {
         alt els {
           some(_else) {
             alt _else.node {
@@ -809,7 +809,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
         }
       }
       ast::expr_bind(func, args) {
-        fn print_opt(s: ps, expr: option::t<@ast::expr>) {
+        fn print_opt(s: ps, expr: option<@ast::expr>) {
             alt expr {
               some(expr) { print_expr(s, expr); }
               _ { word(s.s, "_"); }
@@ -1411,8 +1411,8 @@ fn print_mt(s: ps, mt: ast::mt) {
 }
 
 fn print_ty_fn(s: ps, opt_proto: option<ast::proto>,
-               decl: ast::fn_decl, id: option::t<ast::ident>,
-               tps: option::t<[ast::ty_param]>) {
+               decl: ast::fn_decl, id: option<ast::ident>,
+               tps: option<[ast::ty_param]>) {
     ibox(s, indent_unit);
     word(s.s, opt_proto_to_str(opt_proto));
     alt id { some(id) { word(s.s, " "); word(s.s, id); } _ { } }
@@ -1442,7 +1442,7 @@ fn print_ty_fn(s: ps, opt_proto: option<ast::proto>,
 }
 
 fn maybe_print_trailing_comment(s: ps, span: codemap::span,
-                                next_pos: option::t<uint>) {
+                                next_pos: option<uint>) {
     let cm;
     alt s.cm { some(ccm) { cm = ccm; } _ { ret; } }
     alt next_comment(s) {
@@ -1512,7 +1512,7 @@ fn print_literal(s: ps, &&lit: @ast::lit) {
 
 fn lit_to_str(l: @ast::lit) -> str { be to_str(l, print_literal); }
 
-fn next_lit(s: ps, pos: uint) -> option::t<lexer::lit> {
+fn next_lit(s: ps, pos: uint) -> option<lexer::lit> {
     alt s.literals {
       some(lits) {
         while s.cur_lit < vec::len(lits) {
@@ -1621,7 +1621,7 @@ fn to_str<T>(t: T, f: fn@(ps, T)) -> str {
     io::mem_buffer_str(buffer)
 }
 
-fn next_comment(s: ps) -> option::t<lexer::cmnt> {
+fn next_comment(s: ps) -> option<lexer::cmnt> {
     alt s.comments {
       some(cmnts) {
         if s.cur_cmnt < vec::len(cmnts) {
diff --git a/src/comp/syntax/visit.rs b/src/comp/syntax/visit.rs
index 2ba0567c213..de8b53af2c4 100644
--- a/src/comp/syntax/visit.rs
+++ b/src/comp/syntax/visit.rs
@@ -264,7 +264,7 @@ fn visit_decl<E>(d: @decl, e: E, v: vt<E>) {
     }
 }
 
-fn visit_expr_opt<E>(eo: option::t<@expr>, e: E, v: vt<E>) {
+fn visit_expr_opt<E>(eo: option<@expr>, e: E, v: vt<E>) {
     alt eo { none { } some(ex) { v.visit_expr(ex, e, v); } }
 }
 
@@ -295,7 +295,7 @@ fn visit_expr<E>(ex: @expr, e: E, v: vt<E>) {
       }
       expr_bind(callee, args) {
         v.visit_expr(callee, e, v);
-        for eo: option::t<@expr> in args { visit_expr_opt(eo, e, v); }
+        for eo: option<@expr> in args { visit_expr_opt(eo, e, v); }
       }
       expr_binary(_, a, b) { v.visit_expr(a, e, v); v.visit_expr(b, e, v); }
       expr_unary(_, a) { v.visit_expr(a, e, v); }