mathieu/os-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Convert alt to match. Stop parsing alt

Browse source
This commit is contained in:
Brian Anderson 2012-08-06 12:34:08 -07:00
parent d3a9bb1bd4
commit ecaf9e39c9
359 changed files with 2938 additions and 2915 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

40
doc/rust.md
View file

@ -209,7 +209,7 @@ import export use mod
The keywords in [source files](#source-files) are the following strings:
~~~~~~~~ {.keyword}
alt again assert
again assert
break
check class const copy
drop
@ -217,7 +217,7 @@ else enum export extern
fail false fn for
if impl import
let log loop
mod mut
match mod mut
pure
return
true trait type
@ -956,7 +956,7 @@ An example of a predicate that uses an unchecked block:
# import std::list::*;
fn pure_foldl<T, U: copy>(ls: list<T>, u: U, f: fn(&&T, &&U) -> U) -> U {
alt ls {
match ls {
nil => u,
cons(hd, tl) => f(hd, pure_foldl(*tl, f(hd, u), f))
}
@ -1156,7 +1156,7 @@ class file_descriptor {
let mut name: option<~str>;
}
fn get_name() -> ~str {
alt self.name {
match self.name {
none => fail ~"File has no name!",
some(n) => n
}
@ -2171,21 +2171,21 @@ evaluated. If all `if` and `else if` conditions evaluate to `false`
then any `else` block is executed.
### Alternative expressions
### Match expressions
~~~~~~~~{.ebnf .gram}
alt_expr : "alt" expr '{' alt_arm [ '|' alt_arm ] * '}' ;
match_expr : "match" expr '{' match_arm [ '|' match_arm ] * '}' ;
alt_arm : alt_pat '=>' expr_or_blockish ;
match_arm : match_pat '=>' expr_or_blockish ;
alt_pat : pat [ "to" pat ] ? [ "if" expr ] ;
match_pat : pat [ "to" pat ] ? [ "if" expr ] ;
~~~~~~~~
An `alt` expression branches on a *pattern*. The exact form of matching that
A `match` expression branches on a *pattern*. The exact form of matching that
occurs depends on the pattern. Patterns consist of some combination of
literals, destructured enum constructors, records and tuples, variable binding
specifications, wildcards (`*`), and placeholders (`_`). An `alt` expression has a *head
specifications, wildcards (`*`), and placeholders (`_`). A `match` expression has a *head
expression*, which is the value to compare to the patterns. The type of the
patterns must equal the type of the head expression.
@ -2198,7 +2198,7 @@ enum list<X> { nil, cons(X, @list<X>) }
let x: list<int> = cons(10, @cons(11, @nil));
alt x {
match x {
cons(_, @nil) => fail ~"singleton list",
cons(*) => return,
nil => fail ~"empty list"
@ -2210,13 +2210,13 @@ tail value of `@nil`. The second pattern matches `any` list constructed with `co
ignoring the values of its arguments. The difference between `_` and `*` is that the pattern `C(_)` is only type-correct if
`C` has exactly one argument, while the pattern `C(*)` is type-correct for any enum variant `C`, regardless of how many arguments `C` has.
To execute an `alt` expression, first the head expression is evaluated, then
To execute an `match` expression, first the head expression is evaluated, then
its value is sequentially compared to the patterns in the arms until a match
is found. The first arm with a matching pattern is chosen as the branch target
of the `alt`, any variables bound by the pattern are assigned to local
of the `match`, any variables bound by the pattern are assigned to local
variables in the arm's block, and control enters the block.
An example of an `alt` expression:
An example of an `match` expression:
~~~~
@ -2227,7 +2227,7 @@ enum list<X> { nil, cons(X, @list<X>) }
let x: list<int> = cons(10, @cons(11, @nil));
alt x {
match x {
cons(a, @cons(b, _)) => {
process_pair(a,b);
}
@ -2264,7 +2264,7 @@ fn main() {
}
};
alt r {
match r {
{options: {choose: true, _}, _} => {
choose_player(r)
}
@ -2278,20 +2278,20 @@ fn main() {
}
~~~~
Multiple alternative patterns may be joined with the `|` operator. A
Multiple match patterns may be joined with the `|` operator. A
range of values may be specified with `to`. For example:
~~~~
# let x = 2;
let message = alt x {
let message = match x {
0 | 1 => ~"not many",
2 to 9 => ~"a few",
_ => ~"lots"
};
~~~~
Finally, alt patterns can accept *pattern guards* to further refine the
Finally, match patterns can accept *pattern guards* to further refine the
criteria for matching a case. Pattern guards appear after the pattern and
consist of a bool-typed expression following the `if` keyword. A pattern
guard may refer to the variables bound within the pattern they follow.
@ -2301,7 +2301,7 @@ guard may refer to the variables bound within the pattern they follow.
# fn process_digit(i: int) { }
# fn process_other(i: int) { }
let message = alt maybe_digit {
let message = match maybe_digit {
some(x) if x < 10 => process_digit(x),
some(x) => process_other(x),
none => fail

34
doc/tutorial.md
View file

@ -116,7 +116,7 @@ fn main() {
let pick = || (~[rock, paper, scissors])[rng.gen_uint() % 3];
// Pick two gestures and decide the result
alt (pick(), pick()) {
match (pick(), pick()) {
(rock, scissors) | (paper, rock) | (scissors, paper) => copy player1,
(scissors, rock) | (rock, paper) | (paper, scissors) => copy player2,
_ => ~"tie"
@ -707,14 +707,14 @@ have type `int`, because control doesn't reach the end of that arm
## Pattern matching
Rust's `alt` construct is a generalized, cleaned-up version of C's
Rust's `match` construct is a generalized, cleaned-up version of C's
`switch` construct. You provide it with a value and a number of arms,
each labelled with a pattern, and it will execute the arm that matches
the value.
~~~~
# let my_number = 1;
alt my_number {
match my_number {
0 => io::println(~"zero"),
1 | 2 => io::println(~"one or two"),
3 to 10 => io::println(~"three to ten"),
@ -732,14 +732,14 @@ valid patterns, and will match only their own value. The pipe operator
of numeric literal patterns can be expressed with `to`. The underscore
(`_`) is a wildcard pattern that matches everything.
The patterns in an alt arm are followed by a fat arrow, `=>`, then an
The patterns in an match arm are followed by a fat arrow, `=>`, then an
expression to evaluate. Each case is separated by commas. It's often
convenient to use a block expression for a case, in which case the
commas are optional.
~~~
# let my_number = 1;
alt my_number {
match my_number {
0 => {
io::println(~"zero")
}
@ -750,9 +750,9 @@ alt my_number {
~~~
If the arm with the wildcard pattern was left off in the above
example, the typechecker would reject it at compile time. `alt`
example, the typechecker would reject it at compile time. `match`
constructs must be exhaustive: they must have an arm covering every
possible case. (You may use the `alt check` construct to write a
possible case. (You may use the `match check` construct to write a
non-exhaustive match, but it's highly undesirable to do so. You may
reason that the missing cases will never occur, but the typechecker
provides you with no assurance that your reasoning is correct.)
@ -763,7 +763,7 @@ that `(float, float)` is a tuple of two floats:
~~~~
fn angle(vec: (float, float)) -> float {
alt vec {
match vec {
(0f, y) if y < 0f => 1.5 * float::consts::pi,
(0f, y) => 0.5 * float::consts::pi,
(x, y) => float::atan(y / x)
@ -777,7 +777,7 @@ y)` matches any tuple whose first element is zero, and binds `y` to
the second element. `(x, y)` matches any tuple, and binds both
elements to a variable.
Any `alt` arm can have a guard clause (written `if EXPR`), which is
Any `match` arm can have a guard clause (written `if EXPR`), which is
an expression of type `bool` that determines, after the pattern is
found to match, whether the arm is taken or not. The variables bound
by the pattern are available in this guard expression.
@ -851,7 +851,7 @@ task failure:
* Accessing an out-of-bounds element of a vector.
* Having no clauses match when evaluating an `alt check` expression.
* Having no clauses match when evaluating an `match check` expression.
* An assertion failure.
@ -1044,14 +1044,14 @@ not an actual new type.)
## Record patterns
Records can be destructured in `alt` patterns. The basic syntax is
Records can be destructured in `match` patterns. The basic syntax is
`{fieldname: pattern, ...}`, but the pattern for a field can be
omitted as a shorthand for simply binding the variable with the same
name as the field.
~~~~
# let mypoint = {x: 0f, y: 0f};
alt mypoint {
match mypoint {
{x: 0f, y: y_name} => { /* Provide sub-patterns for fields */ }
{x, y} => { /* Simply bind the fields */ }
}
@ -1157,7 +1157,7 @@ patterns, as in this definition of `area`:
# type point = {x: float, y: float};
# enum shape { circle(point, float), rectangle(point, point) }
fn area(sh: shape) -> float {
alt sh {
match sh {
circle(_, size) => float::consts::pi * size * size,
rectangle({x, y}, {x: x2, y: y2}) => (x2 - x) * (y2 - y)
}
@ -1170,7 +1170,7 @@ Another example, matching nullary enum variants:
# type point = {x: float, y: float};
# enum direction { north, east, south, west }
fn point_from_direction(dir: direction) -> point {
alt dir {
match dir {
north => {x: 0f, y: 1f},
east => {x: 1f, y: 0f},
south => {x: 0f, y: -1f},
@ -1188,7 +1188,7 @@ nil, `()`, as the empty tuple if you like).
~~~~
let mytup: (int, int, float) = (10, 20, 30.0);
alt mytup {
match mytup {
(a, b, c) => log(info, a + b + (c as int))
}
~~~~
@ -1922,7 +1922,7 @@ gets access to them.
## Other uses of safe references
Safe references are not only used for argument passing. When you
destructure on a value in an `alt` expression, or loop over a vector
destructure on a value in a `match` expression, or loop over a vector
with `for`, variables bound to the inside of the given data structure
will use safe references, not copies. This means such references are
very cheap, but you'll occasionally have to copy them to ensure
@ -1930,7 +1930,7 @@ safety.
~~~~
let mut my_rec = {a: 4, b: ~[1, 2, 3]};
alt my_rec {
match my_rec {
{a, b} => {
log(info, b); // This is okay
my_rec = {a: a + 1, b: b + ~[a]};

134
src/cargo/cargo.rs
View file

@ -128,7 +128,7 @@ fn is_uuid(id: ~str) -> bool {
return false;
}
alt i {
match i {
0u => {
if str::len(part) == 8u {
correct += 1u;
@ -192,7 +192,7 @@ fn is_archive_url(u: ~str) -> bool {
// FIXME (#2661): this requires the protocol bit - if we had proper
// url parsing, we wouldn't need it
alt str::find_str(u, ~"://") {
match str::find_str(u, ~"://") {
option::some(i) => has_archive_extension(u),
_ => false
}
@ -223,9 +223,9 @@ fn load_link(mis: ~[@ast::meta_item]) -> (option<~str>,
let mut vers = none;
let mut uuid = none;
for mis.each |a| {
alt a.node {
match a.node {
ast::meta_name_value(v, {node: ast::lit_str(s), span: _}) => {
alt *v {
match *v {
~"name" => name = some(*s),
~"vers" => vers = some(*s),
~"uuid" => uuid = some(*s),
@ -250,9 +250,9 @@ fn load_crate(filename: ~str) -> option<crate> {
let mut crate_type = none;
for c.node.attrs.each |a| {
alt a.node.value.node {
match a.node.value.node {
ast::meta_name_value(v, {node: ast::lit_str(s), span: _}) => {
alt *v {
match *v {
~"desc" => desc = some(*v),
~"sigs" => sigs = some(*v),
~"crate_type" => crate_type = some(*v),
@ -279,7 +279,7 @@ fn load_crate(filename: ~str) -> option<crate> {
};
fn goto_view_item(e: env, i: @ast::view_item) {
alt i.node {
match i.node {
ast::view_item_use(ident, metas, id) => {
let name_items =
attr::find_meta_items_by_name(metas, ~"name");
@ -293,11 +293,11 @@ fn load_crate(filename: ~str) -> option<crate> {
let mut attr_from = ~"";
for m.each |item| {
alt attr::get_meta_item_value_str(item) {
match attr::get_meta_item_value_str(item) {
some(value) => {
let name = attr::get_meta_item_name(item);
alt *name {
match *name {
~"vers" => attr_vers = *value,
~"from" => attr_from = *value,
_ => ()
@ -315,7 +315,7 @@ fn load_crate(filename: ~str) -> option<crate> {
} else { *attr_name }
};
alt *attr_name {
match *attr_name {
~"std" | ~"core" => (),
_ => vec::push(e.deps, query)
}
@ -339,7 +339,7 @@ fn load_crate(filename: ~str) -> option<crate> {
let deps = copy e.deps;
alt (name, vers, uuid) {
match (name, vers, uuid) {
(some(name0), some(vers0), some(uuid0)) => {
some({
name: name0,
@ -390,21 +390,21 @@ fn parse_source(name: ~str, j: json::json) -> source {
fail fmt!{"'%s' is an invalid source name", name};
}
alt j {
match j {
json::dict(j) => {
let mut url = alt j.find(~"url") {
let mut url = match j.find(~"url") {
some(json::string(u)) => *u,
_ => fail ~"needed 'url' field in source"
};
let method = alt j.find(~"method") {
let method = match j.find(~"method") {
some(json::string(u)) => *u,
_ => assume_source_method(url)
};
let key = alt j.find(~"key") {
let key = match j.find(~"key") {
some(json::string(u)) => some(*u),
_ => none
};
let keyfp = alt j.find(~"keyfp") {
let keyfp = match j.find(~"keyfp") {
some(json::string(u)) => some(*u),
_ => none
};
@ -426,7 +426,7 @@ fn parse_source(name: ~str, j: json::json) -> source {
fn try_parse_sources(filename: ~str, sources: map::hashmap<~str, source>) {
if !os::path_exists(filename) { return; }
let c = io::read_whole_file_str(filename);
alt json::from_str(result::get(c)) {
match json::from_str(result::get(c)) {
ok(json::dict(j)) => {
for j.each |k, v| {
sources.insert(k, parse_source(k, v));
@ -439,7 +439,7 @@ fn try_parse_sources(filename: ~str, sources: map::hashmap<~str, source>) {
}
fn load_one_source_package(src: source, p: map::hashmap<~str, json::json>) {
let name = alt p.find(~"name") {
let name = match p.find(~"name") {
some(json::string(n)) => {
if !valid_pkg_name(*n) {
warn(~"malformed source json: "
@ -456,7 +456,7 @@ fn load_one_source_package(src: source, p: map::hashmap<~str, json::json>) {
}
};
let uuid = alt p.find(~"uuid") {
let uuid = match p.find(~"uuid") {
some(json::string(n)) => {
if !is_uuid(*n) {
warn(~"malformed source json: "
@ -472,7 +472,7 @@ fn load_one_source_package(src: source, p: map::hashmap<~str, json::json>) {
}
};
let url = alt p.find(~"url") {
let url = match p.find(~"url") {
some(json::string(n)) => *n,
_ => {
warn(~"malformed source json: " + src.name + ~" (missing url)");
@ -480,7 +480,7 @@ fn load_one_source_package(src: source, p: map::hashmap<~str, json::json>) {
}
};
let method = alt p.find(~"method") {
let method = match p.find(~"method") {
some(json::string(n)) => *n,
_ => {
warn(~"malformed source json: "
@ -489,16 +489,16 @@ fn load_one_source_package(src: source, p: map::hashmap<~str, json::json>) {
}
};
let reference = alt p.find(~"ref") {
let reference = match p.find(~"ref") {
some(json::string(n)) => some(*n),
_ => none
};
let mut tags = ~[];
alt p.find(~"tags") {
match p.find(~"tags") {
some(json::list(js)) => {
for (*js).each |j| {
alt j {
match j {
json::string(j) => vec::grow(tags, 1u, *j),
_ => ()
}
@ -507,7 +507,7 @@ fn load_one_source_package(src: source, p: map::hashmap<~str, json::json>) {
_ => ()
}
let description = alt p.find(~"description") {
let description = match p.find(~"description") {
some(json::string(n)) => *n,
_ => {
warn(~"malformed source json: " + src.name
@ -527,7 +527,7 @@ fn load_one_source_package(src: source, p: map::hashmap<~str, json::json>) {
versions: ~[]
};
alt vec::position(src.packages, |pkg| pkg.uuid == uuid) {
match vec::position(src.packages, |pkg| pkg.uuid == uuid) {
some(idx) => {
src.packages[idx] = newpkg;
log(debug, ~" updated package: " + src.name + ~"/" + name);
@ -545,7 +545,7 @@ fn load_source_info(c: cargo, src: source) {
let srcfile = path::connect(dir, ~"source.json");
if !os::path_exists(srcfile) { return; }
let srcstr = io::read_whole_file_str(srcfile);
alt json::from_str(result::get(srcstr)) {
match json::from_str(result::get(srcstr)) {
ok(json::dict(s)) => {
let o = parse_source(src.name, json::dict(s));
@ -567,10 +567,10 @@ fn load_source_packages(c: cargo, src: source) {
let pkgfile = path::connect(dir, ~"packages.json");
if !os::path_exists(pkgfile) { return; }
let pkgstr = io::read_whole_file_str(pkgfile);
alt json::from_str(result::get(pkgstr)) {
match json::from_str(result::get(pkgstr)) {
ok(json::list(js)) => {
for (*js).each |j| {
alt j {
match j {
json::dict(p) => {
load_one_source_package(src, p);
}
@ -592,7 +592,7 @@ fn load_source_packages(c: cargo, src: source) {
}
fn build_cargo_options(argv: ~[~str]) -> options {
let matches = alt getopts::getopts(argv, opts()) {
let matches = match getopts::getopts(argv, opts()) {
result::ok(m) => m,
result::err(f) => {
fail fmt!{"%s", getopts::fail_str(f)};
@ -623,12 +623,12 @@ fn build_cargo_options(argv: ~[~str]) -> options {
}
fn configure(opts: options) -> cargo {
let home = alt get_cargo_root() {
let home = match get_cargo_root() {
ok(home) => home,
err(_err) => result::get(get_cargo_sysroot())
};
let get_cargo_dir = alt opts.mode {
let get_cargo_dir = match opts.mode {
system_mode => get_cargo_sysroot,
user_mode => get_cargo_root,
local_mode => get_cargo_root_nearest
@ -716,7 +716,7 @@ fn run_in_buildpath(what: ~str, path: ~str, subdir: ~str, cf: ~str,
}
fn test_one_crate(_c: cargo, path: ~str, cf: ~str) {
let buildpath = alt run_in_buildpath(~"testing", path, ~"/test", cf,
let buildpath = match run_in_buildpath(~"testing", path, ~"/test", cf,
~[ ~"--test"]) {
none => return,
some(bp) => bp
@ -725,7 +725,7 @@ fn test_one_crate(_c: cargo, path: ~str, cf: ~str) {
}
fn install_one_crate(c: cargo, path: ~str, cf: ~str) {
let buildpath = alt run_in_buildpath(~"installing", path,
let buildpath = match run_in_buildpath(~"installing", path,
~"/build", cf, ~[]) {
none => return,
some(bp) => bp
@ -752,7 +752,7 @@ fn install_one_crate(c: cargo, path: ~str, cf: ~str) {
fn rustc_sysroot() -> ~str {
alt os::self_exe_path() {
match os::self_exe_path() {
some(path) => {
let path = ~[path, ~"..", ~"bin", ~"rustc"];
let rustc = path::normalize(path::connect_many(path));
@ -779,7 +779,7 @@ fn install_source(c: cargo, path: ~str) {
}
for cratefiles.each |cf| {
alt load_crate(cf) {
match load_crate(cf) {
none => again,
some(crate) => {
for crate.deps.each |query| {
@ -788,7 +788,7 @@ fn install_source(c: cargo, path: ~str) {
// condition")
let wd_base = c.workdir + path::path_sep();
let wd = alt tempfile::mkdtemp(wd_base, ~"") {
let wd = match tempfile::mkdtemp(wd_base, ~"") {
some(wd) => wd,
none => fail fmt!{"needed temp dir: %s", wd_base}
};
@ -838,7 +838,7 @@ fn install_file(c: cargo, wd: ~str, path: ~str) {
fn install_package(c: cargo, src: ~str, wd: ~str, pkg: package) {
let url = copy pkg.url;
let method = alt pkg.method {
let method = match pkg.method {
~"git" => ~"git",
~"file" => ~"file",
_ => ~"curl"
@ -846,7 +846,7 @@ fn install_package(c: cargo, src: ~str, wd: ~str, pkg: package) {
info(fmt!{"installing %s/%s via %s...", src, pkg.name, method});
alt method {
match method {
~"git" => install_git(c, wd, url, copy pkg.reference),
~"file" => install_file(c, wd, url),
~"curl" => install_curl(c, wd, copy url),
@ -913,7 +913,7 @@ fn install_named(c: cargo, wd: ~str, name: ~str) {
}
fn install_uuid_specific(c: cargo, wd: ~str, src: ~str, uuid: ~str) {
alt c.sources.find(src) {
match c.sources.find(src) {
some(s) => {
let packages = copy s.packages;
if vec::any(packages, |p| {
@ -929,7 +929,7 @@ fn install_uuid_specific(c: cargo, wd: ~str, src: ~str, uuid: ~str) {
}
fn install_named_specific(c: cargo, wd: ~str, src: ~str, name: ~str) {
alt c.sources.find(src) {
match c.sources.find(src) {
some(s) => {
let packages = copy s.packages;
if vec::any(packages, |p| {
@ -960,7 +960,7 @@ fn cmd_uninstall(c: cargo) {
// name only)
if is_uuid(target) {
for os::list_dir(lib).each |file| {
alt str::find_str(file, ~"-" + target + ~"-") {
match str::find_str(file, ~"-" + target + ~"-") {
some(idx) => {
let full = path::normalize(path::connect(lib, file));
if os::remove_file(full) {
@ -977,7 +977,7 @@ fn cmd_uninstall(c: cargo) {
error(~"can't find package with uuid: " + target);
} else {
for os::list_dir(lib).each |file| {
alt str::find_str(file, ~"lib" + target + ~"-") {
match str::find_str(file, ~"lib" + target + ~"-") {
some(idx) => {
let full = path::normalize(path::connect(lib,
file));
@ -992,7 +992,7 @@ fn cmd_uninstall(c: cargo) {
}
}
for os::list_dir(bin).each |file| {
alt str::find_str(file, target) {
match str::find_str(file, target) {
some(idx) => {
let full = path::normalize(path::connect(bin, file));
if os::remove_file(full) {
@ -1011,7 +1011,7 @@ fn cmd_uninstall(c: cargo) {
}
fn install_query(c: cargo, wd: ~str, target: ~str) {
alt c.dep_cache.find(target) {
match c.dep_cache.find(target) {
some(inst) => {
if inst {
return;
@ -1038,7 +1038,7 @@ fn install_query(c: cargo, wd: ~str, target: ~str) {
} else {
let mut ps = copy target;
alt str::find_char(ps, '/') {
match str::find_char(ps, '/') {
option::some(idx) => {
let source = str::slice(ps, 0u, idx);
ps = str::slice(ps, idx + 1u, str::len(ps));
@ -1072,7 +1072,7 @@ fn install_query(c: cargo, wd: ~str, target: ~str) {
fn cmd_install(c: cargo) unsafe {
let wd_base = c.workdir + path::path_sep();
let wd = alt tempfile::mkdtemp(wd_base, ~"") {
let wd = match tempfile::mkdtemp(wd_base, ~"") {
some(wd) => wd,
none => fail fmt!{"needed temp dir: %s", wd_base}
};
@ -1129,7 +1129,7 @@ fn sync_one_file(c: cargo, dir: ~str, src: source) -> bool {
os::copy_file(path::connect(url, ~"source.json.sig"), srcsigfile);
os::copy_file(path::connect(url, ~"packages.json.sig"), sigfile);
alt copy src.key {
match copy src.key {
some(u) => {
let p = run::program_output(~"curl",
~[~"-f", ~"-s", ~"-o", keyfile, u]);
@ -1141,7 +1141,7 @@ fn sync_one_file(c: cargo, dir: ~str, src: source) -> bool {
}
_ => ()
}
alt (src.key, src.keyfp) {
match (src.key, src.keyfp) {
(some(_), some(f)) => {
let r = pgp::verify(c.root, pkgfile, sigfile, f);
@ -1238,7 +1238,7 @@ fn sync_one_git(c: cargo, dir: ~str, src: source) -> bool {
let has_src_file = os::path_exists(srcfile);
alt copy src.key {
match copy src.key {
some(u) => {
let p = run::program_output(~"curl",
~[~"-f", ~"-s", ~"-o", keyfile, u]);
@ -1251,7 +1251,7 @@ fn sync_one_git(c: cargo, dir: ~str, src: source) -> bool {
}
_ => ()
}
alt (src.key, src.keyfp) {
match (src.key, src.keyfp) {
(some(_), some(f)) => {
let r = pgp::verify(c.root, pkgfile, sigfile, f);
@ -1318,7 +1318,7 @@ fn sync_one_curl(c: cargo, dir: ~str, src: source) -> bool {
}
}
alt copy src.key {
match copy src.key {
some(u) => {
let p = run::program_output(~"curl",
~[~"-f", ~"-s", ~"-o", keyfile, u]);
@ -1330,7 +1330,7 @@ fn sync_one_curl(c: cargo, dir: ~str, src: source) -> bool {
}
_ => ()
}
alt (src.key, src.keyfp) {
match (src.key, src.keyfp) {
(some(_), some(f)) => {
if smart {
url = src.url + ~"/packages.json.sig";
@ -1403,7 +1403,7 @@ fn sync_one(c: cargo, src: source) {
need_dir(dir);
let result = alt src.method {
let result = match src.method {
~"git" => sync_one_git(c, dir, src),
~"file" => sync_one_file(c, dir, src),
_ => sync_one_curl(c, dir, src)
@ -1490,7 +1490,7 @@ fn cmd_list(c: cargo) {
if !valid_pkg_name(name) {
error(fmt!{"'%s' is an invalid source name", name});
} else {
alt c.sources.find(name) {
match c.sources.find(name) {
some(source) => {
print_source(source);
}
@ -1562,7 +1562,7 @@ fn dump_sources(c: cargo) {
copy_warn(out, path::connect(c.root, ~"sources.json.old"));
}
alt io::buffered_file_writer(out) {
match io::buffered_file_writer(out) {
result::ok(writer) => {
let hash = map::str_hash();
let root = json::dict(hash);
@ -1574,13 +1574,13 @@ fn dump_sources(c: cargo) {
chash.insert(~"url", json::string(@v.url));
chash.insert(~"method", json::string(@v.method));
alt copy v.key {
match copy v.key {
some(key) => {
chash.insert(~"key", json::string(@key));
}
_ => ()
}
alt copy v.keyfp {
match copy v.keyfp {
some(keyfp) => {
chash.insert(~"keyfp", json::string(@keyfp));
}
@ -1615,7 +1615,7 @@ fn cmd_sources(c: cargo) {
let action = c.opts.free[2u];
alt action {
match action {
~"clear" => {
for c.sources.each_key |k| {
c.sources.remove(k);
@ -1637,7 +1637,7 @@ fn cmd_sources(c: cargo) {
return;
}
alt c.sources.find(name) {
match c.sources.find(name) {
some(source) => {
error(fmt!{"source already exists: %s", name});
}
@ -1667,7 +1667,7 @@ fn cmd_sources(c: cargo) {
return;
}
alt c.sources.find(name) {
match c.sources.find(name) {
some(source) => {
c.sources.remove(name);
info(fmt!{"removed source: %s", name});
@ -1691,7 +1691,7 @@ fn cmd_sources(c: cargo) {
return;
}
alt c.sources.find(name) {
match c.sources.find(name) {
some(source) => {
let old = copy source.url;
let method = assume_source_method(url);
@ -1722,11 +1722,11 @@ fn cmd_sources(c: cargo) {
return;
}
alt c.sources.find(name) {
match c.sources.find(name) {
some(source) => {
let old = copy source.method;
source.method = alt method {
source.method = match method {
~"git" => ~"git",
~"file" => ~"file",
_ => ~"curl"
@ -1760,7 +1760,7 @@ fn cmd_sources(c: cargo) {
return;
}
alt c.sources.find(name) {
match c.sources.find(name) {
some(source) => {
c.sources.remove(name);
c.sources.insert(newn, source);
@ -1874,7 +1874,7 @@ fn main(argv: ~[~str]) {
return;
}
if o.help {
alt o.free[1] {
match o.free[1] {
~"init" => cmd_usage_init(),
~"install" => cmd_usage_install(),
~"uninstall" => cmd_usage_uninstall(),
@ -1901,7 +1901,7 @@ fn main(argv: ~[~str]) {
c = configure(o);
}
alt o.free[1] {
match o.free[1] {
~"init" => cmd_init(c),
~"install" => cmd_install(c),
~"uninstall" => cmd_uninstall(c),

14
src/compiletest/compiletest.rs
View file

@ -37,7 +37,7 @@ fn parse_config(args: ~[~str]) -> config {
assert (vec::is_not_empty(args));
let args_ = vec::tail(args);
let matches =
alt getopts::getopts(args_, opts) {
match getopts::getopts(args_, opts) {
ok(m) => m,
err(f) => fail getopts::fail_str(f)
};
@ -80,7 +80,7 @@ fn log_config(config: config) {
}
fn opt_str(maybestr: option<~str>) -> ~str {
alt maybestr { option::some(s) => s, option::none => ~"(none)" }
match maybestr { option::some(s) => s, option::none => ~"(none)" }
}
fn str_opt(maybestr: ~str) -> option<~str> {
@ -88,7 +88,7 @@ fn str_opt(maybestr: ~str) -> option<~str> {
}
fn str_mode(s: ~str) -> mode {
alt s {
match s {
~"compile-fail" => mode_compile_fail,
~"run-fail" => mode_run_fail,
~"run-pass" => mode_run_pass,
@ -98,7 +98,7 @@ fn str_mode(s: ~str) -> mode {
}
fn mode_str(mode: mode) -> ~str {
alt mode {
match mode {
mode_compile_fail => ~"compile-fail",
mode_run_fail => ~"run-fail",
mode_run_pass => ~"run-pass",
@ -115,13 +115,13 @@ fn run_tests(config: config) {
fn test_opts(config: config) -> test::test_opts {
{filter:
alt config.filter {
match config.filter {
option::some(s) => option::some(s),
option::none => option::none
},
run_ignored: config.run_ignored,
logfile:
alt config.logfile {
match config.logfile {
option::some(s) => option::some(s),
option::none => option::none
}
@ -144,7 +144,7 @@ fn make_tests(config: config) -> ~[test::test_desc] {
fn is_test(config: config, testfile: ~str) -> bool {
// Pretty-printer does not work with .rc files yet
let valid_extensions =
alt config.mode {
match config.mode {
mode_pretty => ~[~".rs"],
_ => ~[~".rc", ~".rs"]
};

2
src/compiletest/errors.rs
View file

@ -23,7 +23,7 @@ fn load_errors(testfile: ~str) -> ~[expected_error] {
fn parse_expected(line_num: uint, line: ~str) -> ~[expected_error] unsafe {
let error_tag = ~"//~";
let mut idx;
alt str::find_str(line, error_tag) {
match str::find_str(line, error_tag) {
option::none => return ~[],
option::some(nn) => { idx = (nn as uint) + str::len(error_tag); }
}

8
src/compiletest/header.rs
View file

@ -30,7 +30,7 @@ fn load_props(testfile: ~str) -> test_props {
let mut compile_flags = option::none;
let mut pp_exact = option::none;
for iter_header(testfile) |ln| {
alt parse_error_pattern(ln) {
match parse_error_pattern(ln) {
option::some(ep) => vec::push(error_patterns, ep),
option::none => ()
};
@ -107,7 +107,7 @@ fn parse_exec_env(line: ~str) -> option<(~str, ~str)> {
do parse_name_value_directive(line, ~"exec-env").map |nv| {
// nv is either FOO or FOO=BAR
let strs = str::splitn_char(nv, '=', 1u);
alt strs.len() {
match strs.len() {
1u => (strs[0], ~""),
2u => (strs[0], strs[1]),
n => fail fmt!{"Expected 1 or 2 strings, not %u", n}
@ -116,7 +116,7 @@ fn parse_exec_env(line: ~str) -> option<(~str, ~str)> {
}
fn parse_pp_exact(line: ~str, testfile: ~str) -> option<~str> {
alt parse_name_value_directive(line, ~"pp-exact") {
match parse_name_value_directive(line, ~"pp-exact") {
option::some(s) => option::some(s),
option::none => {
if parse_name_directive(line, ~"pp-exact") {
@ -135,7 +135,7 @@ fn parse_name_directive(line: ~str, directive: ~str) -> bool {
fn parse_name_value_directive(line: ~str,
directive: ~str) -> option<~str> unsafe {
let keycolon = directive + ~":";
alt str::find_str(line, keycolon) {
match str::find_str(line, keycolon) {
option::some(colon) => {
let value = str::slice(line, colon + str::len(keycolon),
str::len(line));

2
src/compiletest/procsrv.rs
View file

@ -76,7 +76,7 @@ fn run(lib_path: ~str,
let mut outs = ~"";
let mut count = 2;
while count > 0 {
alt p.recv() {
match p.recv() {
(1, s) => {
outs = s;
}

10
src/compiletest/runtest.rs
View file

@ -18,7 +18,7 @@ fn run(config: config, testfile: ~str) {
}
debug!{"running %s", testfile};
let props = load_props(testfile);
alt config.mode {
match config.mode {
mode_compile_fail => run_cfail_test(config, props, testfile),
mode_run_fail => run_rfail_test(config, props, testfile),
mode_run_pass => run_rpass_test(config, props, testfile),
@ -90,7 +90,7 @@ fn run_pretty_test(config: config, props: test_props, testfile: ~str) {
} else { logv(config, ~"testing for converging pretty-printing"); }
let rounds =
alt props.pp_exact { option::some(_) => 1, option::none => 2 };
match props.pp_exact { option::some(_) => 1, option::none => 2 };
let mut srcs = ~[result::get(io::read_whole_file_str(testfile))];
@ -109,7 +109,7 @@ fn run_pretty_test(config: config, props: test_props, testfile: ~str) {
}
let mut expected =
alt props.pp_exact {
match props.pp_exact {
option::some(file) => {
let filepath = path::connect(path::dirname(testfile), file);
result::get(io::read_whole_file_str(filepath))
@ -383,7 +383,7 @@ fn make_run_args(config: config, _props: test_props, testfile: ~str) ->
// If we've got another tool to run under (valgrind),
// then split apart its command
let runtool =
alt config.runtool {
match config.runtool {
option::some(s) => option::some(s),
option::none => option::none
};
@ -402,7 +402,7 @@ fn split_maybe_args(argstr: option<~str>) -> ~[~str] {
vec::filter_map(v, flt)
}
alt argstr {
match argstr {
option::some(s) => rm_whitespace(str::split_char(s, ' ')),
option::none => ~[]
}

2
src/compiletest/util.rs
View file

@ -7,7 +7,7 @@ fn make_new_path(path: ~str) -> ~str {
// Windows just uses PATH as the library search path, so we have to
// maintain the current value while adding our own
alt getenv(lib_path_env_var()) {
match getenv(lib_path_env_var()) {
option::some(curr) => {
fmt!{"%s%s%s", path, path_div(), curr}
}

18
src/fuzzer/fuzzer.rs
View file

@ -62,9 +62,9 @@ pure fn safe_to_steal_expr(e: @ast::expr, tm: test_mode) -> bool {
}
pure fn safe_to_use_expr(e: ast::expr, tm: test_mode) -> bool {
alt tm {
match tm {
tm_converge => {
alt e.node {
match e.node {
// If the fuzzer moves a block-ending-in-semicolon into callee
// position, the pretty-printer can't preserve this even by
// parenthesizing!! See email to marijn.
@ -139,7 +139,7 @@ fn steal(crate: ast::crate, tm: test_mode) -> stolen_stuff {
fn safe_to_replace_expr(e: ast::expr_, _tm: test_mode) -> bool {
alt e {
match e {
// https://github.com/mozilla/rust/issues/652
ast::expr_if(*) => { false }
ast::expr_block(_) => { false }
@ -152,7 +152,7 @@ fn safe_to_replace_expr(e: ast::expr_, _tm: test_mode) -> bool {
}
fn safe_to_replace_ty(t: ast::ty_, _tm: test_mode) -> bool {
alt t {
match t {
ast::ty_infer => { false } // always implicit, always top level
ast::ty_bot => { false } // in source, can only appear
// as the out type of a function
@ -272,7 +272,7 @@ fn check_variants_T<T: copy>(
io::str_reader(~""), a,
pprust::no_ann(),
false));
alt cx.mode {
match cx.mode {
tm_converge => {
check_roundtrip_convergence(str3, 1u);
}
@ -314,12 +314,12 @@ fn check_whole_compiler(code: ~str, suggested_filename_prefix: ~str,
let compile_result = check_compiling(filename);
let run_result = alt (compile_result, allow_running) {
let run_result = match (compile_result, allow_running) {
(passed, true) => { check_running(suggested_filename_prefix) }
(h, _) => { h }
};
alt run_result {
match run_result {
passed | cleanly_rejected(_) | known_bug(_) => {
removeIfExists(suggested_filename_prefix);
removeIfExists(suggested_filename_prefix + ~".rs");
@ -364,7 +364,7 @@ fn check_running(exe_filename: ~str) -> happiness {
} else if contains(comb, ~"malloc") {
failed(~"Mentioned malloc")
} else {
alt p.status {
match p.status {
0 => { passed }
100 => { cleanly_rejected(~"running: explicit fail") }
101 | 247 => { cleanly_rejected(~"running: timed out") }
@ -441,7 +441,7 @@ fn parse_and_print(code: @~str) -> ~str {
fn has_raw_pointers(c: ast::crate) -> bool {
let has_rp = @mut false;
fn visit_ty(flag: @mut bool, t: @ast::ty) {
alt t.node {
match t.node {
ast::ty_ptr(_) => { *flag = true; }
_ => { }
}

2
src/libcore/bool.rs
View file

@ -39,7 +39,7 @@ pure fn is_false(v: bool) -> bool { !v }
/// Parse logic value from `s`
pure fn from_str(s: ~str) -> option<bool> {
alt check s {
match check s {
~"true" => some(true),
~"false" => some(false),
_ => none

4
src/libcore/char.rs
View file

@ -113,7 +113,7 @@ pure fn is_digit(c: char) -> bool {
* refer to a digit in the given radix.
*/
pure fn to_digit(c: char, radix: uint) -> option<uint> {
let val = alt c {
let val = match c {
'0' to '9' => c as uint - ('0' as uint),
'a' to 'z' => c as uint + 10u - ('a' as uint),
'A' to 'Z' => c as uint + 10u - ('A' as uint),
@ -158,7 +158,7 @@ fn escape_unicode(c: char) -> ~str {
* - Any other chars are given hex unicode escapes; see `escape_unicode`.
*/
fn escape_default(c: char) -> ~str {
alt c {
match c {
'\t' => ~"\\t",
'\r' => ~"\\r",
'\n' => ~"\\n",

2
src/libcore/comm.rs
View file

@ -409,7 +409,7 @@ fn test_select2_stress() {
let mut as = 0;
let mut bs = 0;
for iter::repeat(msgs * times * 2u) {
alt check select2(po_a, po_b) {
match check select2(po_a, po_b) {
either::left(~"a") => as += 1,
either::right(~"b") => bs += 1
}

20
src/libcore/dlist.rs
View file

@ -26,8 +26,8 @@ enum dlist<T> = @{
impl private_methods<T> for dlist_node<T> {
pure fn assert_links() {
alt self.next {
some(neighbour) => alt neighbour.prev {
match self.next {
some(neighbour) => match neighbour.prev {
some(me) => if !box::ptr_eq(*self, *me) {
fail ~"Asymmetric next-link in dlist node."
}
@ -35,8 +35,8 @@ impl private_methods<T> for dlist_node<T> {
}
none => ()
}
alt self.prev {
some(neighbour) => alt neighbour.next {
match self.prev {
some(neighbour) => match neighbour.next {
some(me) => if !box::ptr_eq(*me, *self) {
fail ~"Asymmetric prev-link in dlist node."
}
@ -55,7 +55,7 @@ impl extensions<T> for dlist_node<T> {
}
/// Get the next node in the list, failing if there isn't one.
pure fn next_node() -> dlist_node<T> {
alt self.next_link() {
match self.next_link() {
some(nobe) => nobe,
none => fail ~"This dlist node has no next neighbour."
}
@ -67,7 +67,7 @@ impl extensions<T> for dlist_node<T> {
}
/// Get the previous node in the list, failing if there isn't one.
pure fn prev_node() -> dlist_node<T> {
alt self.prev_link() {
match self.prev_link() {
some(nobe) => nobe,
none => fail ~"This dlist node has no previous neighbour."
}
@ -138,11 +138,11 @@ impl private_methods<T> for dlist<T> {
// the head and/or tail pointers appropriately.
#[inline(always)]
fn link(+before: dlist_link<T>, +after: dlist_link<T>) {
alt before {
match before {
some(neighbour) => neighbour.next = after,
none => self.hd = after
}
alt after {
match after {
some(neighbour) => neighbour.prev = before,
none => self.tl = before
}
@ -286,14 +286,14 @@ impl extensions<T> for dlist<T> {
/// Get the node at the list's head, failing if empty. O(1).
pure fn head_n() -> dlist_node<T> {
alt self.hd {
match self.hd {
some(nobe) => nobe,
none => fail ~"Attempted to get the head of an empty dlist."
}
}
/// Get the node at the list's tail, failing if empty. O(1).
pure fn tail_n() -> dlist_node<T> {
alt self.tl {
match self.tl {
some(nobe) => nobe,
none => fail ~"Attempted to get the tail of an empty dlist."
}

2
src/libcore/dvec.rs
View file

@ -222,7 +222,7 @@ impl extensions<A:copy> for dvec<A> {
*/
fn append_iter<A, I:iter::base_iter<A>>(ts: I) {
do self.swap |v| {
let mut v = alt ts.size_hint() {
let mut v = match ts.size_hint() {
none { v }
some(h) {
let len = v.len() + h;

16
src/libcore/either.rs
View file

@ -18,7 +18,7 @@ fn either<T, U, V>(f_left: fn(T) -> V,
* result is returned.
*/
alt value {
match value {
left(l) => f_left(l),
right(r) => f_right(r)
}
@ -29,7 +29,7 @@ fn lefts<T: copy, U>(eithers: ~[either<T, U>]) -> ~[T] {
let mut result: ~[T] = ~[];
for vec::each(eithers) |elt| {
alt elt {
match elt {
left(l) => vec::push(result, l),
_ => { /* fallthrough */ }
}
@ -42,7 +42,7 @@ fn rights<T, U: copy>(eithers: ~[either<T, U>]) -> ~[U] {
let mut result: ~[U] = ~[];
for vec::each(eithers) |elt| {
alt elt {
match elt {
right(r) => vec::push(result, r),
_ => { /* fallthrough */ }
}
@ -62,7 +62,7 @@ fn partition<T: copy, U: copy>(eithers: ~[either<T, U>])
let mut lefts: ~[T] = ~[];
let mut rights: ~[U] = ~[];
for vec::each(eithers) |elt| {
alt elt {
match elt {
left(l) => vec::push(lefts, l),
right(r) => vec::push(rights, r)
}
@ -73,7 +73,7 @@ fn partition<T: copy, U: copy>(eithers: ~[either<T, U>])
pure fn flip<T: copy, U: copy>(eith: either<T, U>) -> either<U, T> {
//! Flips between left and right of a given either
alt eith {
match eith {
right(r) => left(r),
left(l) => right(l)
}
@ -88,7 +88,7 @@ pure fn to_result<T: copy, U: copy>(
* an ok result, and the "left" choice a fail
*/
alt eith {
match eith {
right(r) => result::ok(r),
left(l) => result::err(l)
}
@ -97,13 +97,13 @@ pure fn to_result<T: copy, U: copy>(
pure fn is_left<T, U>(eith: either<T, U>) -> bool {
//! Checks whether the given value is a left
alt eith { left(_) => true, _ => false }
match eith { left(_) => true, _ => false }
}
pure fn is_right<T, U>(eith: either<T, U>) -> bool {
//! Checks whether the given value is a right
alt eith { right(_) => true, _ => false }
match eith { right(_) => true, _ => false }
}
#[test]

24
src/libcore/extfmt.rs
View file

@ -122,7 +122,7 @@ mod ct {
let c = s[i];
if !('0' as u8 <= c && c <= '9' as u8) { return option::none; }
let n = (c - ('0' as u8)) as uint;
return alt peek_num(s, i + 1u, lim) {
return match peek_num(s, i + 1u, lim) {
none => some({num: n, next: i + 1u}),
some(next) => {
let m = next.num;
@ -150,7 +150,7 @@ mod ct {
{param: option<int>, next: uint} {
if i >= lim { return {param: none, next: i}; }
let num = peek_num(s, i, lim);
return alt num {
return match num {
none => {param: none, next: i},
some(t) => {
let n = t.num;
@ -195,13 +195,13 @@ mod ct {
} else if s[i] == '*' as u8 {
let param = parse_parameter(s, i + 1u, lim);
let j = param.next;
alt param.param {
match param.param {
none => {count: count_is_next_param, next: j},
some(n) => {count: count_is_param(n), next: j}
}
} else {
let num = peek_num(s, i, lim);
alt num {
match num {
none => {count: count_implied, next: i},
some(num) => {
count: count_is(num.num as int),
@ -220,7 +220,7 @@ mod ct {
// If there were no digits specified, i.e. the precision
// was ".", then the precision is 0
alt count.count {
match count.count {
count_implied => {count: count_is(0), next: count.next},
_ => count
}
@ -294,7 +294,7 @@ mod rt {
pure fn conv_uint(cv: conv, u: uint) -> ~str {
let prec = get_int_precision(cv);
let mut rs =
alt cv.ty {
match cv.ty {
ty_default => uint_to_str_prec(u, 10u, prec),
ty_hex_lower => uint_to_str_prec(u, 16u, prec),
ty_hex_upper => str::to_upper(uint_to_str_prec(u, 16u, prec)),
@ -316,7 +316,7 @@ mod rt {
pure fn conv_str(cv: conv, s: &str) -> ~str {
// For strings, precision is the maximum characters
// displayed
let mut unpadded = alt cv.precision {
let mut unpadded = match cv.precision {
count_implied => s.to_unique(),
count_is(max) => if max as uint < str::char_len(s) {
str::substr(s, 0u, max as uint)
@ -327,7 +327,7 @@ mod rt {
return unchecked { pad(cv, unpadded, pad_nozero) };
}
pure fn conv_float(cv: conv, f: float) -> ~str {
let (to_str, digits) = alt cv.precision {
let (to_str, digits) = match cv.precision {
count_is(c) => (float::to_str_exact, c as uint),
count_implied => (float::to_str, 6u)
};
@ -371,14 +371,14 @@ mod rt {
};
}
pure fn get_int_precision(cv: conv) -> uint {
return alt cv.precision {
return match cv.precision {
count_is(c) => c as uint,
count_implied => 1u
};
}
enum pad_mode { pad_signed, pad_unsigned, pad_nozero, pad_float }
fn pad(cv: conv, &s: ~str, mode: pad_mode) -> ~str {
let uwidth : uint = alt cv.width {
let uwidth : uint = match cv.width {
count_implied => return s,
count_is(width) => {
// FIXME: width should probably be uint (see Issue #1996)
@ -393,14 +393,14 @@ mod rt {
let padstr = str::from_chars(vec::from_elem(diff, padchar));
return s + padstr;
}
let {might_zero_pad, signed} = alt mode {
let {might_zero_pad, signed} = match mode {
pad_nozero => {might_zero_pad:false, signed:false},
pad_signed => {might_zero_pad:true, signed:true },
pad_float => {might_zero_pad:true, signed:true},
pad_unsigned => {might_zero_pad:true, signed:false}
};
pure fn have_precision(cv: conv) -> bool {
return alt cv.precision { count_implied => false, _ => true };
return match cv.precision { count_implied => false, _ => true };
}
let zero_padding = {
if might_zero_pad && have_flag(cv.flags, flag_left_zero_pad) &&

14
src/libcore/float.rs
View file

@ -256,14 +256,14 @@ fn from_str(num: ~str) -> option<float> {
let mut c = 'z'; //Latest char.
//The string must start with one of the following characters.
alt str::char_at(num, 0u) {
match str::char_at(num, 0u) {
'-' | '+' | '0' to '9' | '.' => (),
_ => return none
}
//Determine if first char is '-'/'+'. Set [pos] and [neg] accordingly.
let mut neg = false; //Sign of the result
alt str::char_at(num, 0u) {
match str::char_at(num, 0u) {
'-' => {
neg = true;
pos = 1u;
@ -279,7 +279,7 @@ fn from_str(num: ~str) -> option<float> {
let char_range = str::char_range_at(num, pos);
c = char_range.ch;
pos = char_range.next;
alt c {
match c {
'0' to '9' => {
total = total * 10f;
total += ((c as int) - ('0' as int)) as float;
@ -295,7 +295,7 @@ fn from_str(num: ~str) -> option<float> {
let char_range = str::char_range_at(num, pos);
c = char_range.ch;
pos = char_range.next;
alt c {
match c {
'0' | '1' | '2' | '3' | '4' | '5' | '6'| '7' | '8' | '9' => {
decimal /= 10f;
total += (((c as int) - ('0' as int)) as float)*decimal;
@ -312,7 +312,7 @@ fn from_str(num: ~str) -> option<float> {
if(pos < len) {
let char_range = str::char_range_at(num, pos);
c = char_range.ch;
alt c {
match c {
'+' => {
pos = char_range.next;
}
@ -325,7 +325,7 @@ fn from_str(num: ~str) -> option<float> {
while(pos < len) {
let char_range = str::char_range_at(num, pos);
c = char_range.ch;
alt c {
match c {
'0' | '1' | '2' | '3' | '4' | '5' | '6'| '7' | '8' | '9' => {
exponent *= 10u;
exponent += ((c as uint) - ('0' as uint));
@ -447,7 +447,7 @@ fn test_from_str() {
assert from_str(~"inf") == some(infinity);
assert from_str(~"-inf") == some(neg_infinity);
// note: NaN != NaN, hence this slightly complex test
alt from_str(~"NaN") {
match from_str(~"NaN") {
some(f) => assert is_NaN(f),
none => fail
}

4
src/libcore/future.rs
View file

@ -77,7 +77,7 @@ fn from_port<A:send>(-port: future_pipe::client::waiting<A>) -> future<A> {
let mut port_ = none;
port_ <-> *port;
let port = option::unwrap(port_);
alt recv(port) {
match recv(port) {
future_pipe::completed(data) => move_it!{data}
}
}
@ -119,7 +119,7 @@ fn get<A:copy>(future: future<A>) -> A {
fn with<A,B>(future: future<A>, blk: fn(A) -> B) -> B {
//! Work with the value without copying it
let v = alt copy future.v {
let v = match copy future.v {
either::left(v) => v,
either::right(f) => {
let v = @f();

2
src/libcore/int-template.rs
View file

@ -144,7 +144,7 @@ fn parse_buf(buf: ~[u8], radix: uint) -> option<T> {
}
let mut n = 0 as T;
loop {
alt char::to_digit(buf[i] as char, radix) {
match char::to_digit(buf[i] as char, radix) {
some(d) => n += (d as T) * power,
none => return none
}

18
src/libcore/io.rs
View file

@ -196,7 +196,7 @@ impl reader_util for reader {
// Reader implementations
fn convert_whence(whence: seek_style) -> i32 {
return alt whence {
return match whence {
seek_set => 0i32,
seek_cur => 1i32,
seek_end => 2i32
@ -440,7 +440,7 @@ fn mk_file_writer(path: ~str, flags: ~[fileflag])
let mut fflags: c_int = wb();
for vec::each(flags) |f| {
alt f {
match f {
append => fflags |= O_APPEND as c_int,
create => fflags |= O_CREAT as c_int,
truncate => fflags |= O_TRUNC as c_int,
@ -460,7 +460,7 @@ fn mk_file_writer(path: ~str, flags: ~[fileflag])
fn u64_to_le_bytes<T>(n: u64, size: uint, f: fn(v: &[u8]) -> T) -> T {
assert size <= 8u;
alt size {
match size {
1u => f(&[n as u8]),
2u => f(&[n as u8,
(n >> 8) as u8]),
@ -491,7 +491,7 @@ fn u64_to_le_bytes<T>(n: u64, size: uint, f: fn(v: &[u8]) -> T) -> T {
fn u64_to_be_bytes<T>(n: u64, size: uint, f: fn(v: &[u8]) -> T) -> T {
assert size <= 8u;
alt size {
match size {
1u => f(&[n as u8]),
2u => f(&[(n >> 8) as u8,
n as u8]),
@ -717,7 +717,7 @@ fn seek_in_buf(offset: int, pos: uint, len: uint, whence: seek_style) ->
uint {
let mut bpos = pos as int;
let blen = len as int;
alt whence {
match whence {
seek_set => bpos = offset,
seek_cur => bpos += offset,
seek_end => bpos = blen + offset
@ -767,7 +767,7 @@ mod fsync {
let arg: arg<t>;
new(-arg: arg<t>) { self.arg <- arg; }
drop {
alt self.arg.opt_level {
match self.arg.opt_level {
option::none => (),
option::some(level) => {
// fail hard if not succesful
@ -891,7 +891,7 @@ mod tests {
#[test]
fn file_reader_not_exist() {
alt io::file_reader(~"not a file") {
match io::file_reader(~"not a file") {
result::err(e) => {
assert e == ~"error opening not a file";
}
@ -901,7 +901,7 @@ mod tests {
#[test]
fn file_writer_bad_name() {
alt io::file_writer(~"?/?", ~[]) {
match io::file_writer(~"?/?", ~[]) {
result::err(e) => {
assert str::starts_with(e, ~"error opening ?/?");
}
@ -911,7 +911,7 @@ mod tests {
#[test]
fn buffered_file_writer_bad_name() {
alt io::buffered_file_writer(~"?/?") {
match io::buffered_file_writer(~"?/?") {
result::err(e) => {
assert e == ~"error opening ?/?";
}

4
src/libcore/iter-trait/option.rs
View file

@ -1,14 +1,14 @@
type IMPL_T<A> = option<A>;
pure fn EACH<A>(self: IMPL_T<A>, f: fn(A) -> bool) {
alt self {
match self {
none => (),
some(a) => { f(a); }
}
}
fn SIZE_HINT<A>(self: IMPL_T<A>) -> option<uint> {
alt self {
match self {
none => some(0u),
some(_) => some(1u)
}

8
src/libcore/iter.rs
View file

@ -134,8 +134,8 @@ fn repeat(times: uint, blk: fn() -> bool) {
}
fn min<A:copy,IA:base_iter<A>>(self: IA) -> A {
alt do foldl::<A,option<A>,IA>(self, none) |a, b| {
alt a {
match do foldl::<A,option<A>,IA>(self, none) |a, b| {
match a {
some(a_) if a_ < b => {
// FIXME (#2005): Not sure if this is successfully optimized to
// a move
@ -150,8 +150,8 @@ fn min<A:copy,IA:base_iter<A>>(self: IA) -> A {
}
fn max<A:copy,IA:base_iter<A>>(self: IA) -> A {
alt do foldl::<A,option<A>,IA>(self, none) |a, b| {
alt a {
match do foldl::<A,option<A>,IA>(self, none) |a, b| {
match a {
some(a_) if a_ > b => {
// FIXME (#2005): Not sure if this is successfully optimized to
// a move.

18
src/libcore/option.rs
View file

@ -23,7 +23,7 @@ pure fn get<T: copy>(opt: option<T>) -> T {
* Fails if the value equals `none`
*/
alt opt {
match opt {
some(x) => return x,
none => fail ~"option::get none"
}
@ -37,13 +37,13 @@ pure fn expect<T: copy>(opt: option<T>, reason: ~str) -> T {
Fails if the value equals `none`
"];
alt opt { some(x) => x, none => fail reason }
match opt { some(x) => x, none => fail reason }
}
pure fn map<T, U>(opt: option<T>, f: fn(T) -> U) -> option<U> {
//! Maps a `some` value from one type to another
alt opt { some(x) => some(f(x)), none => none }
match opt { some(x) => some(f(x)), none => none }
}
pure fn map_consume<T, U>(-opt: option<T>, f: fn(-T) -> U) -> option<U> {
@ -60,7 +60,7 @@ pure fn chain<T, U>(opt: option<T>, f: fn(T) -> option<U>) -> option<U> {
* function that returns an option.
*/
alt opt { some(x) => f(x), none => none }
match opt { some(x) => f(x), none => none }
}
#[inline(always)]
@ -76,7 +76,7 @@ pure fn while_some<T>(+x: option<T>, blk: fn(+T) -> option<T>) {
pure fn is_none<T>(opt: option<T>) -> bool {
//! Returns true if the option equals `none`
alt opt { none => true, some(_) => false }
match opt { none => true, some(_) => false }
}
pure fn is_some<T>(opt: option<T>) -> bool {
@ -88,19 +88,19 @@ pure fn is_some<T>(opt: option<T>) -> bool {
pure fn get_default<T: copy>(opt: option<T>, def: T) -> T {
//! Returns the contained value or a default
alt opt { some(x) => x, none => def }
match opt { some(x) => x, none => def }
}
pure fn map_default<T, U>(opt: option<T>, +def: U, f: fn(T) -> U) -> U {
//! Applies a function to the contained value or returns a default
alt opt { none => def, some(t) => f(t) }
match opt { none => def, some(t) => f(t) }
}
pure fn iter<T>(opt: option<T>, f: fn(T)) {
//! Performs an operation on the contained value or does nothing
alt opt { none => (), some(t) => f(t) }
match opt { none => (), some(t) => f(t) }
}
#[inline(always)]
@ -113,7 +113,7 @@ pure fn unwrap<T>(-opt: option<T>) -> T {
*/
unsafe {
let addr = alt opt {
let addr = match opt {
some(x) => ptr::addr_of(x),
none => fail ~"option::unwrap none"
};

8
src/libcore/os.rs
View file

@ -178,7 +178,7 @@ mod global_env {
unsafe {
do priv::weaken_task |weak_po| {
loop {
alt comm::select2(msg_po, weak_po) {
match comm::select2(msg_po, weak_po) {
either::left(msg_getenv(n, resp_ch)) => {
comm::send(resp_ch, impl::getenv(n))
}
@ -282,7 +282,7 @@ fn fsync_fd(fd: c_int, _level: io::fsync::level) -> c_int {
#[cfg(target_os = "linux")]
fn fsync_fd(fd: c_int, level: io::fsync::level) -> c_int {
import libc::funcs::posix01::unistd::*;
alt level {
match level {
io::fsync::fsync
| io::fsync::fullfsync => return fsync(fd),
io::fsync::fdatasync => return fdatasync(fd)
@ -294,7 +294,7 @@ fn fsync_fd(fd: c_int, level: io::fsync::level) -> c_int {
import libc::consts::os::extra::*;
import libc::funcs::posix88::fcntl::*;
import libc::funcs::posix01::unistd::*;
alt level {
match level {
io::fsync::fsync => return fsync(fd),
_ => {
// According to man fnctl, the ok retval is only specified to be !=-1
@ -440,7 +440,7 @@ fn self_exe_path() -> option<path> {
* Otherwise, homedir returns option::none.
*/
fn homedir() -> option<path> {
return alt getenv(~"HOME") {
return match getenv(~"HOME") {
some(p) => if !str::is_empty(p) {
some(p)
} else {

2
src/libcore/path.rs
View file

@ -61,7 +61,7 @@ fn path_is_absolute(p: ~str) -> bool {
fn path_sep() -> ~str { return str::from_char(consts::path_sep); }
fn split_dirname_basename (pp: path) -> {dirname: ~str, basename: ~str} {
alt str::rfind(pp, |ch|
match str::rfind(pp, |ch|
ch == consts::path_sep || ch == consts::alt_path_sep
) {
some(i) => {

42
src/libcore/pipes.rs
View file

@ -136,7 +136,7 @@ struct packet_header {
unsafe fn unblock() {
let old_task = swap_task(self.blocked_task, ptr::null());
if !old_task.is_null() { rustrt::rust_task_deref(old_task) }
alt swap_state_acq(self.state, empty) {
match swap_state_acq(self.state, empty) {
empty | blocked => (),
terminated => self.state = terminated,
full => self.state = full
@ -345,7 +345,7 @@ fn send<T: send, Tbuffer: send>(-p: send_packet_buffered<T, Tbuffer>,
assert p.payload == none;
p.payload <- some(payload);
let old_state = swap_state_rel(p.header.state, full);
alt old_state {
match old_state {
empty => {
// Yay, fastpath.
@ -403,7 +403,7 @@ fn try_recv<T: send, Tbuffer: send>(-p: recv_packet_buffered<T, Tbuffer>)
rustrt::task_clear_event_reject(this);
let old_state = swap_state_acq(p.header.state,
blocked);
alt old_state {
match old_state {
empty => {
debug!{"no data available on %?, going to sleep.", p_};
if count == 0 {
@ -451,7 +451,7 @@ fn try_recv<T: send, Tbuffer: send>(-p: recv_packet_buffered<T, Tbuffer>)
/// Returns true if messages are available.
pure fn peek<T: send, Tb: send>(p: recv_packet_buffered<T, Tb>) -> bool {
alt unsafe {(*p.header()).state} {
match unsafe {(*p.header()).state} {
empty => false,
blocked => fail ~"peeking on blocked packet",
full | terminated => true
@ -467,7 +467,7 @@ impl peek<T: send, Tb: send> for recv_packet_buffered<T, Tb> {
#[doc(hidden)]
fn sender_terminate<T: send>(p: *packet<T>) {
let p = unsafe { &*p };
alt swap_state_rel(p.header.state, terminated) {
match swap_state_rel(p.header.state, terminated) {
empty => {
assert p.header.blocked_task.is_null();
// The receiver will eventually clean up.
@ -500,7 +500,7 @@ fn sender_terminate<T: send>(p: *packet<T>) {
fn receiver_terminate<T: send>(p: *packet<T>) {
let p = unsafe { &*p };
assert p.header.blocked_task.is_null();
alt swap_state_rel(p.header.state, terminated) {
match swap_state_rel(p.header.state, terminated) {
empty => {
// the sender will clean up
//unsafe { forget(p) }
@ -534,7 +534,7 @@ fn wait_many(pkts: &[*packet_header]) -> uint {
for pkts.eachi |i, p| unsafe {
let p = unsafe { &*p };
let old = p.mark_blocked(this);
alt old {
match old {
full | terminated => {
data_avail = true;
ready_packet = i;
@ -551,7 +551,7 @@ fn wait_many(pkts: &[*packet_header]) -> uint {
let event = wait_event(this) as *packet_header;
let pos = vec::position(pkts, |p| p == event);
alt pos {
match pos {
some(i) => {
ready_packet = i;
data_avail = true;
@ -611,7 +611,7 @@ fn select2<A: send, Ab: send, B: send, Bb: send>(
let i = wait_many([a.header(), b.header()]/_);
unsafe {
alt i {
match i {
0 => left((try_recv(a), b)),
1 => right((a, try_recv(b))),
_ => fail ~"select2 return an invalid packet"
@ -631,7 +631,7 @@ fn selecti<T: selectable>(endpoints: &[T]) -> uint {
/// Returns 0 or 1 depending on which endpoint is ready to receive
fn select2i<A: selectable, B: selectable>(a: A, b: B) -> either<(), ()> {
alt wait_many([a.header(), b.header()]/_) {
match wait_many([a.header(), b.header()]/_) {
0 => left(()),
1 => right(()),
_ => fail ~"wait returned unexpected index"
@ -704,7 +704,7 @@ struct send_packet_buffered<T: send, Tbuffer: send> {
}
pure fn header() -> *packet_header {
alt self.p {
match self.p {
some(packet) => unsafe {
let packet = &*packet;
let header = ptr::addr_of(packet.header);
@ -765,7 +765,7 @@ struct recv_packet_buffered<T: send, Tbuffer: send> : selectable {
}
pure fn header() -> *packet_header {
alt self.p {
match self.p {
some(packet) => unsafe {
let packet = &*packet;
let header = ptr::addr_of(packet.header);
@ -924,7 +924,7 @@ impl port<T: send> of recv<T> for port<T> {
fn try_recv() -> option<T> {
let mut endp = none;
endp <-> self.endp;
alt move pipes::try_recv(unwrap(endp)) {
match move pipes::try_recv(unwrap(endp)) {
some(streamp::data(x, endp)) => {
self.endp = some(move_it!{endp});
some(move_it!{x})
@ -936,7 +936,7 @@ impl port<T: send> of recv<T> for port<T> {
pure fn peek() -> bool unchecked {
let mut endp = none;
endp <-> self.endp;
let peek = alt endp {
let peek = match endp {
some(endp) => pipes::peek(endp),
none => fail ~"peeking empty stream"
};
@ -969,7 +969,7 @@ struct port_set<T: send> : recv<T> {
ports <-> self.ports;
while result == none && ports.len() > 0 {
let i = wait_many(ports.map(|p| p.header()));
alt move ports[i].try_recv() {
match move ports[i].try_recv() {
some(copy m) => {
result = some(move m);
}
@ -1007,7 +1007,7 @@ struct port_set<T: send> : recv<T> {
impl<T: send> of selectable for port<T> {
pure fn header() -> *packet_header unchecked {
alt self.endp {
match self.endp {
some(endp) => endp.header(),
none => fail ~"peeking empty stream"
}
@ -1045,8 +1045,8 @@ impl<T: send, U: send, Left: selectable recv<T>, Right: selectable recv<U>>
of select2<T, U> for (Left, Right) {
fn select() -> either<T, U> {
alt self {
(lp, rp) => alt select2i(lp, rp) {
match self {
(lp, rp) => match select2i(lp, rp) {
left(()) => left (lp.recv()),
right(()) => right(rp.recv())
}
@ -1054,8 +1054,8 @@ impl<T: send, U: send, Left: selectable recv<T>, Right: selectable recv<U>>
}
fn try_select() -> either<option<T>, option<U>> {
alt self {
(lp, rp) => alt select2i(lp, rp) {
match self {
(lp, rp) => match select2i(lp, rp) {
left(()) => left (lp.try_recv()),
right(()) => right(rp.try_recv())
}
@ -1072,7 +1072,7 @@ mod test {
c1.send(~"abc");
alt (p1, p2).select() {
match (p1, p2).select() {
right(_) => fail,
_ => ()
}

2
src/libcore/priv.rs
View file

@ -49,7 +49,7 @@ unsafe fn chan_from_global_ptr<T: send>(
// Wait to hear if we are the official instance of
// this global task
alt comm::recv::<msg>(setup_po) {
match comm::recv::<msg>(setup_po) {
proceed => f(po),
abort => ()
}

40
src/libcore/result.rs
View file

@ -18,7 +18,7 @@ enum result<T, U> {
* If the result is an error
*/
pure fn get<T: copy, U>(res: result<T, U>) -> T {
alt res {
match res {
ok(t) => t,
err(the_err) => unchecked {
fail fmt!{"get called on error result: %?", the_err}
@ -34,7 +34,7 @@ pure fn get<T: copy, U>(res: result<T, U>) -> T {
* If the result is not an error
*/
pure fn get_err<T, U: copy>(res: result<T, U>) -> U {
alt res {
match res {
err(u) => u,
ok(_) => fail ~"get_error called on ok result"
}
@ -42,7 +42,7 @@ pure fn get_err<T, U: copy>(res: result<T, U>) -> U {
/// Returns true if the result is `ok`
pure fn is_ok<T, U>(res: result<T, U>) -> bool {
alt res {
match res {
ok(_) => true,
err(_) => false
}
@ -60,7 +60,7 @@ pure fn is_err<T, U>(res: result<T, U>) -> bool {
* result variants are converted to `either::left`.
*/
pure fn to_either<T: copy, U: copy>(res: result<U, T>) -> either<T, U> {
alt res {
match res {
ok(res) => either::right(res),
err(fail_) => either::left(fail_)
}
@ -82,7 +82,7 @@ pure fn to_either<T: copy, U: copy>(res: result<U, T>) -> either<T, U> {
*/
fn chain<T, U: copy, V: copy>(res: result<T, V>, op: fn(T) -> result<U, V>)
-> result<U, V> {
alt res {
match res {
ok(t) => op(t),
err(e) => err(e)
}
@ -100,7 +100,7 @@ fn chain_err<T: copy, U: copy, V: copy>(
res: result<T, V>,
op: fn(V) -> result<T, U>)
-> result<T, U> {
alt res {
match res {
ok(t) => ok(t),
err(v) => op(v)
}
@ -121,7 +121,7 @@ fn chain_err<T: copy, U: copy, V: copy>(
* }
*/
fn iter<T, E>(res: result<T, E>, f: fn(T)) {
alt res {
match res {
ok(t) => f(t),
err(_) => ()
}
@ -136,7 +136,7 @@ fn iter<T, E>(res: result<T, E>, f: fn(T)) {
* handling an error.
*/
fn iter_err<T, E>(res: result<T, E>, f: fn(E)) {
alt res {
match res {
ok(_) => (),
err(e) => f(e)
}
@ -158,7 +158,7 @@ fn iter_err<T, E>(res: result<T, E>, f: fn(E)) {
*/
fn map<T, E: copy, U: copy>(res: result<T, E>, op: fn(T) -> U)
-> result<U, E> {
alt res {
match res {
ok(t) => ok(op(t)),
err(e) => err(e)
}
@ -174,7 +174,7 @@ fn map<T, E: copy, U: copy>(res: result<T, E>, op: fn(T) -> U)
*/
fn map_err<T: copy, E, F: copy>(res: result<T, E>, op: fn(E) -> F)
-> result<T, F> {
alt res {
match res {
ok(t) => ok(t),
err(e) => err(op(e))
}
@ -186,14 +186,14 @@ impl extensions<T, E> for result<T, E> {
fn is_err() -> bool { is_err(self) }
fn iter(f: fn(T)) {
alt self {
match self {
ok(t) => f(t),
err(_) => ()
}
}
fn iter_err(f: fn(E)) {
alt self {
match self {
ok(_) => (),
err(e) => f(e)
}
@ -204,7 +204,7 @@ impl extensions<T:copy, E> for result<T, E> {
fn get() -> T { get(self) }
fn map_err<F:copy>(op: fn(E) -> F) -> result<T,F> {
alt self {
match self {
ok(t) => ok(t),
err(e) => err(op(e))
}
@ -215,7 +215,7 @@ impl extensions<T, E:copy> for result<T, E> {
fn get_err() -> E { get_err(self) }
fn map<U:copy>(op: fn(T) -> U) -> result<U,E> {
alt self {
match self {
ok(t) => ok(op(t)),
err(e) => err(e)
}
@ -255,7 +255,7 @@ fn map_vec<T,U:copy,V:copy>(
let mut vs: ~[V] = ~[];
vec::reserve(vs, vec::len(ts));
for vec::each(ts) |t| {
alt op(t) {
match op(t) {
ok(v) => vec::push(vs, v),
err(u) => return err(u)
}
@ -266,9 +266,9 @@ fn map_vec<T,U:copy,V:copy>(
fn map_opt<T,U:copy,V:copy>(
o_t: option<T>, op: fn(T) -> result<V,U>) -> result<option<V>,U> {
alt o_t {
match o_t {
none => ok(none),
some(t) => alt op(t) {
some(t) => match op(t) {
ok(v) => ok(some(v)),
err(e) => err(e)
}
@ -293,7 +293,7 @@ fn map_vec2<S,T,U:copy,V:copy>(ss: ~[S], ts: ~[T],
vec::reserve(vs, n);
let mut i = 0u;
while i < n {
alt op(ss[i],ts[i]) {
match op(ss[i],ts[i]) {
ok(v) => vec::push(vs, v),
err(u) => return err(u)
}
@ -314,7 +314,7 @@ fn iter_vec2<S,T,U:copy>(ss: ~[S], ts: ~[T],
let n = vec::len(ts);
let mut i = 0u;
while i < n {
alt op(ss[i],ts[i]) {
match op(ss[i],ts[i]) {
ok(()) => (),
err(u) => return err(u)
}
@ -326,7 +326,7 @@ fn iter_vec2<S,T,U:copy>(ss: ~[S], ts: ~[T],
/// Unwraps a result, assuming it is an `ok(T)`
fn unwrap<T, U>(-res: result<T, U>) -> T {
unsafe {
let addr = alt res {
let addr = match res {
ok(x) => ptr::addr_of(x),
err(_) => fail ~"error result"
};

8
src/libcore/run.rs
View file

@ -96,7 +96,7 @@ fn with_envp<T>(env: option<~[(~str,~str)]>,
cb: fn(*c_void) -> T) -> T {
// On posixy systems we can pass a char** for envp, which is
// a null-terminated array of "k=v\n" strings.
alt env {
match env {
some(es) if !vec::is_empty(es) => {
let mut tmps = ~[];
let mut ptrs = ~[];
@ -123,7 +123,7 @@ fn with_envp<T>(env: option<~[(~str,~str)]>,
// rather a concatenation of null-terminated k=v\0 sequences, with a final
// \0 to terminate.
unsafe {
alt env {
match env {
some(es) if !vec::is_empty(es) => {
let mut blk : ~[u8] = ~[];
for vec::each(es) |e| {
@ -143,7 +143,7 @@ fn with_envp<T>(env: option<~[(~str,~str)]>,
fn with_dirp<T>(d: option<~str>,
cb: fn(*libc::c_char) -> T) -> T {
alt d {
match d {
some(dir) => str::as_c_str(dir, cb),
none => cb(ptr::null())
}
@ -309,7 +309,7 @@ fn program_output(prog: ~str, args: ~[~str]) ->
let mut count = 2;
while count > 0 {
let stream = comm::recv(p);
alt check stream {
match check stream {
(1, s) => {
outs = s;
}

12
src/libcore/send_map.rs
View file

@ -115,7 +115,7 @@ mod linear {
k: &K) -> search_result {
let _ = for self.bucket_sequence(hash) |i| {
alt buckets[i] {
match buckets[i] {
some(bkt) => if bkt.hash == hash && self.eqfn(k, &bkt.key) {
return found_entry(i);
}
@ -155,7 +155,7 @@ mod linear {
/// Assumes that there will be a bucket.
/// True if there was no previous entry with that key
fn insert_internal(hash: uint, +k: K, +v: V) -> bool {
alt self.bucket_for_key_with_hash(self.buckets, hash,
match self.bucket_for_key_with_hash(self.buckets, hash,
unsafe{borrow(k)}) {
table_full => {fail ~"Internal logic error";}
found_hole(idx) => {
@ -207,7 +207,7 @@ mod linear {
// I found this explanation elucidating:
// http://www.maths.lse.ac.uk/Courses/MA407/del-hash.pdf
let mut idx = alt self.bucket_for_key(self.buckets, k) {
let mut idx = match self.bucket_for_key(self.buckets, k) {
table_full | found_hole(_) => {
return false;
}
@ -246,7 +246,7 @@ mod linear {
}
fn contains_key(k: &K) -> bool {
alt self.bucket_for_key(self.buckets, k) {
match self.bucket_for_key(self.buckets, k) {
found_entry(_) => {true}
table_full | found_hole(_) => {false}
}
@ -255,9 +255,9 @@ mod linear {
impl public_methods<K,V: copy> for &const linear_map<K,V> {
fn find(k: &K) -> option<V> {
alt self.bucket_for_key(self.buckets, k) {
match self.bucket_for_key(self.buckets, k) {
found_entry(idx) => {
alt check self.buckets[idx] {
match check self.buckets[idx] {
some(bkt) => {some(copy bkt.value)}
}
}

16
src/libcore/str.rs
View file

@ -341,7 +341,7 @@ fn unshift_char(&s: ~str, ch: char) { s = from_char(ch) + s; }
/// Returns a string with leading whitespace removed
pure fn trim_left(s: &str) -> ~str {
alt find(s, |c| !char::is_whitespace(c)) {
match find(s, |c| !char::is_whitespace(c)) {
none => ~"",
some(first) => unsafe { unsafe::slice_bytes(s, first, len(s)) }
}
@ -349,7 +349,7 @@ pure fn trim_left(s: &str) -> ~str {
/// Returns a string with trailing whitespace removed
pure fn trim_right(s: &str) -> ~str {
alt rfind(s, |c| !char::is_whitespace(c)) {
match rfind(s, |c| !char::is_whitespace(c)) {
none => ~"",
some(last) => {
let {next, _} = char_range_at(s, last);
@ -2776,7 +2776,7 @@ mod tests {
fn test_chars_iter() {
let mut i = 0;
do chars_iter(~"x\u03c0y") |ch| {
alt check i {
match check i {
0 => assert ch == 'x',
1 => assert ch == '\u03c0',
2 => assert ch == 'y'
@ -2792,7 +2792,7 @@ mod tests {
let mut i = 0;
do bytes_iter(~"xyz") |bb| {
alt check i {
match check i {
0 => assert bb == 'x' as u8,
1 => assert bb == 'y' as u8,
2 => assert bb == 'z' as u8
@ -2810,7 +2810,7 @@ mod tests {
let mut ii = 0;
do split_char_iter(data, ' ') |xx| {
alt ii {
match ii {
0 => assert ~"\nMary" == xx,
1 => assert ~"had" == xx,
2 => assert ~"a" == xx,
@ -2828,7 +2828,7 @@ mod tests {
let mut ii = 0;
do splitn_char_iter(data, ' ', 2u) |xx| {
alt ii {
match ii {
0 => assert ~"\nMary" == xx,
1 => assert ~"had" == xx,
2 => assert ~"a little lamb\nLittle lamb\n" == xx,
@ -2845,7 +2845,7 @@ mod tests {
let mut ii = 0;
do words_iter(data) |ww| {
alt ii {
match ii {
0 => assert ~"Mary" == ww,
1 => assert ~"had" == ww,
2 => assert ~"a" == ww,
@ -2865,7 +2865,7 @@ mod tests {
let mut ii = 0;
do lines_iter(lf) |x| {
alt ii {
match ii {
0 => assert ~"" == x,
1 => assert ~"Mary had a little lamb" == x,
2 => assert ~"Little lamb" == x,

28
src/libcore/task.rs
View file

@ -279,7 +279,7 @@ impl task_builder for task_builder {
let ch = comm::chan(po);
blk(do future::from_fn {
alt comm::recv(po) {
match comm::recv(po) {
exit(_, result) => result
}
});
@ -502,7 +502,7 @@ fn try<T:send>(+f: fn~() -> T) -> result<T,()> {
do task().unlinked().future_result(|-r| { result = some(r); }).spawn {
comm::send(ch, f());
}
alt future::get(option::unwrap(result)) {
match future::get(option::unwrap(result)) {
success => result::ok(comm::recv(po)),
failure => result::err(())
}
@ -991,7 +991,7 @@ fn gen_child_taskgroup(linked: bool, supervised: bool)
/*######################################################################*
* Step 1. Get spawner's taskgroup info.
*######################################################################*/
let spawner_group = alt unsafe { local_get(spawner, taskgroup_key()) } {
let spawner_group = match unsafe { local_get(spawner, taskgroup_key()) } {
none => {
// Main task, doing first spawn ever. Lazily initialise here.
let mut members = new_taskset();
@ -1028,7 +1028,7 @@ fn gen_child_taskgroup(linked: bool, supervised: bool)
// assertion, but initialising it requires locking a mutex. Hence
// it should be enabled only in debug builds.
let new_generation =
alt *old_ancestors {
match *old_ancestors {
some(arc) => access_ancestors(arc, |a| a.generation+1),
none => 0 // the actual value doesn't really matter.
};
@ -1047,7 +1047,7 @@ fn gen_child_taskgroup(linked: bool, supervised: bool)
fn share_ancestors(ancestors: &mut ancestor_list) -> ancestor_list {
// Appease the borrow-checker. Really this wants to be written as:
// alt ancestors
// match ancestors
// some(ancestor_arc) { ancestor_list(some(ancestor_arc.clone())) }
// none { ancestor_list(none) }
let tmp = util::replace(&mut **ancestors, none);
@ -1073,7 +1073,7 @@ fn spawn_raw(opts: task_opts, +f: fn~()) {
// Agh. Get move-mode items into the closure. FIXME (#2829)
let (child_tg, ancestors, f) = option::swap_unwrap(child_data);
// Create child task.
let new_task = alt opts.sched {
let new_task = match opts.sched {
none => rustrt::new_task(),
some(sched_opts) => new_task_in_new_sched(sched_opts)
};
@ -1162,7 +1162,7 @@ fn spawn_raw(opts: task_opts, +f: fn~()) {
fail ~"foreign_stack_size scheduler option unimplemented";
}
let num_threads = alt opts.mode {
let num_threads = match opts.mode {
single_threaded => 1u,
thread_per_core => {
fail ~"thread_per_core scheduling mode unimplemented"
@ -1273,7 +1273,7 @@ unsafe fn local_data_lookup<T: owned>(
let key_value = key_to_key_value(key);
let map_pos = (*map).position(|entry|
alt entry {
match entry {
some((k,_,_)) => k == key_value,
none => false
}
@ -1336,7 +1336,7 @@ unsafe fn local_set<T: owned>(
// Construct new entry to store in the map.
let new_entry = some((keyval, data_ptr, data_box));
// Find a place to put it.
alt local_data_lookup(map, key) {
match local_data_lookup(map, key) {
some((index, _old_data_ptr)) => {
// Key already had a value set, _old_data_ptr, whose reference
// will get dropped when the local_data box is overwritten.
@ -1344,7 +1344,7 @@ unsafe fn local_set<T: owned>(
}
none => {
// Find an empty slot. If not, grow the vector.
alt (*map).position(|x| x == none) {
match (*map).position(|x| x == none) {
some(empty_index) => (*map).set_elt(empty_index, new_entry),
none => (*map).push(new_entry)
}
@ -1694,7 +1694,7 @@ fn test_spawn_listiner_bidi() {
#[test]
fn test_try_success() {
alt do try {
match do try {
~"Success!"
} {
result::ok(~"Success!") => (),
@ -1705,7 +1705,7 @@ fn test_try_success() {
#[test]
#[ignore(cfg(windows))]
fn test_try_fail() {
alt do try {
match do try {
fail
} {
result::err(()) => (),
@ -2052,13 +2052,13 @@ fn test_tls_pop() unsafe {
fn test_tls_modify() unsafe {
fn my_key(+_x: @~str) { }
local_data_modify(my_key, |data| {
alt data {
match data {
some(@val) => fail ~"unwelcome value: " + val,
none => some(@~"first data")
}
});
local_data_modify(my_key, |data| {
alt data {
match data {
some(@~"first data") => some(@~"next data"),
some(@val) => fail ~"wrong value: " + val,
none => fail ~"missing value"

4
src/libcore/uint-template.rs
View file

@ -127,7 +127,7 @@ fn parse_buf(buf: ~[u8], radix: uint) -> option<T> {
let mut power = 1u as T;
let mut n = 0u as T;
loop {
alt char::to_digit(buf[i] as char, radix) {
match char::to_digit(buf[i] as char, radix) {
some(d) => n += d as T * power,
none => return none
}
@ -146,7 +146,7 @@ fn from_str_radix(buf: ~str, radix: u64) -> option<u64> {
let mut i = str::len(buf) - 1u;
let mut power = 1u64, n = 0u64;
loop {
alt char::to_digit(buf[i] as char, radix as uint) {
match char::to_digit(buf[i] as char, radix as uint) {
some(d) => n += d as u64 * power,
none => return none
}

64
src/libcore/unicode.rs
View file

@ -1,6 +1,6 @@
mod general_category {
pure fn Cc(c: char) -> bool {
return alt c {
return match c {
'\x00' to '\x1f'
| '\x7f' to '\x9f' => true,
_ => false
@ -8,7 +8,7 @@ mod general_category {
}
pure fn Cf(c: char) -> bool {
return alt c {
return match c {
'\xad'
| '\u0600' to '\u0603'
| '\u06dd'
@ -27,21 +27,21 @@ mod general_category {
}
pure fn Co(c: char) -> bool {
return alt c {
return match c {
'\ue000' to '\uf8ff' => true,
_ => false
};
}
pure fn Cs(c: char) -> bool {
return alt c {
return match c {
'\ud800' to '\udfff' => true,
_ => false
};
}
pure fn Ll(c: char) -> bool {
return alt c {
return match c {
'\x61' to '\x7a'
| '\xaa'
| '\xb5'
@ -646,7 +646,7 @@ mod general_category {
}
pure fn Lm(c: char) -> bool {
return alt c {
return match c {
'\u02b0' to '\u02c1'
| '\u02c6' to '\u02d1'
| '\u02e0' to '\u02e4'
@ -702,7 +702,7 @@ mod general_category {
}
pure fn Lo(c: char) -> bool {
return alt c {
return match c {
'\u01bb'
| '\u01c0' to '\u01c3'
| '\u0294'
@ -888,7 +888,7 @@ mod general_category {
}
pure fn Lt(c: char) -> bool {
return alt c {
return match c {
'\u01c5'
| '\u01c8'
| '\u01cb'
@ -905,7 +905,7 @@ mod general_category {
}
pure fn Lu(c: char) -> bool {
return alt c {
return match c {
'\x41' to '\x5a'
| '\xc0' to '\xd6'
| '\xd8' to '\xde'
@ -1497,7 +1497,7 @@ mod general_category {
}
pure fn Mc(c: char) -> bool {
return alt c {
return match c {
'\u0903'
| '\u093b'
| '\u093e' to '\u0940'
@ -1608,7 +1608,7 @@ mod general_category {
}
pure fn Me(c: char) -> bool {
return alt c {
return match c {
'\u0488' to '\u0489'
| '\u20dd' to '\u20e0'
| '\u20e2' to '\u20e4'
@ -1619,7 +1619,7 @@ mod general_category {
}
pure fn Mn(c: char) -> bool {
return alt c {
return match c {
'\u0300' to '\u036f'
| '\u0483' to '\u0487'
| '\u0591' to '\u05bd'
@ -1812,7 +1812,7 @@ mod general_category {
}
pure fn Nd(c: char) -> bool {
return alt c {
return match c {
'\x30' to '\x39'
| '\u0660' to '\u0669'
| '\u06f0' to '\u06f9'
@ -1856,7 +1856,7 @@ mod general_category {
}
pure fn Nl(c: char) -> bool {
return alt c {
return match c {
'\u16ee' to '\u16f0'
| '\u2160' to '\u2182'
| '\u2185' to '\u2188'
@ -1875,7 +1875,7 @@ mod general_category {
}
pure fn No(c: char) -> bool {
return alt c {
return match c {
'\xb2' to '\xb3'
| '\xb9'
| '\xbc' to '\xbe'
@ -1923,7 +1923,7 @@ mod general_category {
}
pure fn Pc(c: char) -> bool {
return alt c {
return match c {
'\x5f'
| '\u203f' to '\u2040'
| '\u2054'
@ -1936,7 +1936,7 @@ mod general_category {
}
pure fn Pd(c: char) -> bool {
return alt c {
return match c {
'\x2d'
| '\u058a'
| '\u05be'
@ -1958,7 +1958,7 @@ mod general_category {
}
pure fn Pe(c: char) -> bool {
return alt c {
return match c {
'\x29'
| '\x5d'
| '\x7d'
@ -2035,7 +2035,7 @@ mod general_category {
}
pure fn Pf(c: char) -> bool {
return alt c {
return match c {
'\xbb'
| '\u2019'
| '\u201d'
@ -2052,7 +2052,7 @@ mod general_category {
}
pure fn Pi(c: char) -> bool {
return alt c {
return match c {
'\xab'
| '\u2018'
| '\u201b' to '\u201c'
@ -2070,7 +2070,7 @@ mod general_category {
}
pure fn Po(c: char) -> bool {
return alt c {
return match c {
'\x21' to '\x23'
| '\x25' to '\x27'
| '\x2a'
@ -2203,7 +2203,7 @@ mod general_category {
}
pure fn Ps(c: char) -> bool {
return alt c {
return match c {
'\x28'
| '\x5b'
| '\x7b'
@ -2282,7 +2282,7 @@ mod general_category {
}
pure fn Sc(c: char) -> bool {
return alt c {
return match c {
'\x24'
| '\xa2' to '\xa5'
| '\u060b'
@ -2305,7 +2305,7 @@ mod general_category {
}
pure fn Sk(c: char) -> bool {
return alt c {
return match c {
'\x5e'
| '\x60'
| '\xa8'
@ -2339,7 +2339,7 @@ mod general_category {
}
pure fn Sm(c: char) -> bool {
return alt c {
return match c {
'\x2b'
| '\x3c' to '\x3e'
| '\x7c'
@ -2410,7 +2410,7 @@ mod general_category {
}
pure fn So(c: char) -> bool {
return alt c {
return match c {
'\xa6' to '\xa7'
| '\xa9'
| '\xae'
@ -2529,21 +2529,21 @@ mod general_category {
}
pure fn Zl(c: char) -> bool {
return alt c {
return match c {
'\u2028' => true,
_ => false
};
}
pure fn Zp(c: char) -> bool {
return alt c {
return match c {
'\u2029' => true,
_ => false
};
}
pure fn Zs(c: char) -> bool {
return alt c {
return match c {
'\x20'
| '\xa0'
| '\u1680'
@ -2561,7 +2561,7 @@ mod general_category {
mod derived_property {
/// Check if a character has the alphabetic unicode property
pure fn Alphabetic(c: char) -> bool {
return alt c {
return match c {
'\x41' to '\x5a'
| '\x61' to '\x7a'
| '\xaa'
@ -3299,7 +3299,7 @@ mod derived_property {
}
pure fn XID_Continue(c: char) -> bool {
return alt c {
return match c {
'\x30' to '\x39'
| '\x41' to '\x5a'
| '\x5f'
@ -4170,7 +4170,7 @@ mod derived_property {
}
pure fn XID_Start(c: char) -> bool {
return alt c {
return match c {
'\x41' to '\x5a'
| '\x61' to '\x7a'
| '\xaa'

10
src/libcore/vec.rs
View file

@ -356,7 +356,7 @@ fn split<T: copy>(v: &[T], f: fn(T) -> bool) -> ~[~[T]] {
let mut start = 0u;
let mut result = ~[];
while start < ln {
alt position_between(v, start, ln, f) {
match position_between(v, start, ln, f) {
none => break,
some(i) => {
push(result, slice(v, start, i));
@ -380,7 +380,7 @@ fn splitn<T: copy>(v: &[T], n: uint, f: fn(T) -> bool) -> ~[~[T]] {
let mut count = n;
let mut result = ~[];
while start < ln && count > 0u {
alt position_between(v, start, ln, f) {
match position_between(v, start, ln, f) {
none => break,
some(i) => {
push(result, slice(v, start, i));
@ -405,7 +405,7 @@ fn rsplit<T: copy>(v: &[T], f: fn(T) -> bool) -> ~[~[T]] {
let mut end = ln;
let mut result = ~[];
while end > 0u {
alt rposition_between(v, 0u, end, f) {
match rposition_between(v, 0u, end, f) {
none => break,
some(i) => {
push(result, slice(v, i + 1u, end));
@ -429,7 +429,7 @@ fn rsplitn<T: copy>(v: &[T], n: uint, f: fn(T) -> bool) -> ~[~[T]] {
let mut count = n;
let mut result = ~[];
while end > 0u && count > 0u {
alt rposition_between(v, 0u, end, f) {
match rposition_between(v, 0u, end, f) {
none => break,
some(i) => {
push(result, slice(v, i + 1u, end));
@ -713,7 +713,7 @@ pure fn filter_map<T, U: copy>(v: &[T], f: fn(T) -> option<U>)
-> ~[U] {
let mut result = ~[];
for each(v) |elem| {
alt f(elem) {
match f(elem) {
none => {/* no-op */ }
some(result_elem) => unsafe { push(result, result_elem); }
}

4
src/libstd/base64.rs
View file

@ -30,7 +30,7 @@ impl of to_base64 for ~[u8] {
i += 3u;
}
alt check len % 3u {
match check len % 3u {
0u => (),
1u => {
let n = (self[i] as uint) << 16u;
@ -96,7 +96,7 @@ impl of from_base64 for ~[u8] {
} else if ch == '/' {
n |= 0x3Fu;
} else if ch == '=' {
alt len - i {
match len - i {
1u => {
vec::push(r, ((n >> 16u) & 0xFFu) as u8);
vec::push(r, ((n >> 8u ) & 0xFFu) as u8);

32
src/libstd/bitv.rs
View file

@ -179,9 +179,9 @@ class bitv {
if self.nbits != other.nbits {
self.die();
}
alt self.rep {
small(s) => alt other.rep {
small(s1) => alt op {
match self.rep {
small(s) => match other.rep {
small(s1) => match op {
union => s.union(s1),
intersect => s.intersect(s1),
assign => s.become(s1),
@ -189,9 +189,9 @@ class bitv {
}
big(s1) => self.die()
}
big(s) => alt other.rep {
big(s) => match other.rep {
small(_) => self.die(),
big(s1) => alt op {
big(s1) => match op {
union => s.union(s1),
intersect => s.intersect(s1),
assign => s.become(s1),
@ -232,7 +232,7 @@ class bitv {
/// Makes a copy of a bitvector
#[inline(always)]
fn clone() -> ~bitv {
~alt self.rep {
~match self.rep {
small(b) => {
bitv{nbits: self.nbits, rep: small(~small_bitv{bits: b.bits})}
}
@ -249,7 +249,7 @@ class bitv {
#[inline(always)]
pure fn get(i: uint) -> bool {
assert (i < self.nbits);
alt self.rep {
match self.rep {
big(b) => b.get(i),
small(s) => s.get(i)
}
@ -263,7 +263,7 @@ class bitv {
#[inline(always)]
fn set(i: uint, x: bool) {
assert (i < self.nbits);
alt self.rep {
match self.rep {
big(b) => b.set(i, x),
small(s) => s.set(i, x)
}
@ -278,12 +278,12 @@ class bitv {
#[inline(always)]
fn equal(v1: bitv) -> bool {
if self.nbits != v1.nbits { return false; }
alt self.rep {
small(b) => alt v1.rep {
match self.rep {
small(b) => match v1.rep {
small(b1) => b.equals(b1),
_ => false
}
big(s) => alt v1.rep {
big(s) => match v1.rep {
big(s1) => s.equals(s1),
small(_) => return false
}
@ -293,7 +293,7 @@ class bitv {
/// Set all bits to 0
#[inline(always)]
fn clear() {
alt self.rep {
match self.rep {
small(b) => b.clear(),
big(s) => for s.each_storage() |w| { w = 0u }
}
@ -302,7 +302,7 @@ class bitv {
/// Set all bits to 1
#[inline(always)]
fn set_all() {
alt self.rep {
match self.rep {
small(b) => b.set_all(),
big(s) => for s.each_storage() |w| { w = !0u } }
}
@ -310,7 +310,7 @@ class bitv {
/// Invert all bits
#[inline(always)]
fn invert() {
alt self.rep {
match self.rep {
small(b) => b.invert(),
big(s) => for s.each_storage() |w| { w = !w } }
}
@ -329,7 +329,7 @@ class bitv {
/// Returns true if all bits are 1
#[inline(always)]
fn is_true() -> bool {
alt self.rep {
match self.rep {
small(b) => b.is_true(),
_ => {
for self.each() |i| { if !i { return false; } }
@ -350,7 +350,7 @@ class bitv {
/// Returns true if all bits are 0
fn is_false() -> bool {
alt self.rep {
match self.rep {
small(b) => b.is_false(),
big(_) => {
for self.each() |i| { if i { return false; } }

2
src/libstd/c_vec.rs
View file

@ -46,7 +46,7 @@ class dtor_res {
let dtor: option<fn@()>;
new(dtor: option<fn@()>) { self.dtor = dtor; }
drop {
alt self.dtor {
match self.dtor {
option::none => (),
option::some(f) => f()
}

18
src/libstd/deque.rs
View file

@ -41,7 +41,7 @@ fn create<T: copy>() -> t<T> {
return rv;
}
fn get<T: copy>(elts: dvec<cell<T>>, i: uint) -> T {
alt elts.get_elt(i) { some(t) => t, _ => fail }
match elts.get_elt(i) { some(t) => t, _ => fail }
}
type repr<T> = {mut nelts: uint,
@ -238,32 +238,32 @@ mod tests {
fn inteq(&&a: int, &&b: int) -> bool { return a == b; }
fn intboxeq(&&a: @int, &&b: @int) -> bool { return a == b; }
fn taggyeq(a: taggy, b: taggy) -> bool {
alt a {
one(a1) => alt b {
match a {
one(a1) => match b {
one(b1) => return a1 == b1,
_ => return false
}
two(a1, a2) => alt b {
two(a1, a2) => match b {
two(b1, b2) => return a1 == b1 && a2 == b2,
_ => return false
}
three(a1, a2, a3) => alt b {
three(a1, a2, a3) => match b {
three(b1, b2, b3) => return a1 == b1 && a2 == b2 && a3 == b3,
_ => return false
}
}
}
fn taggypareq<T>(a: taggypar<T>, b: taggypar<T>) -> bool {
alt a {
onepar::<T>(a1) => alt b {
match a {
onepar::<T>(a1) => match b {
onepar::<T>(b1) => return a1 == b1,
_ => return false
}
twopar::<T>(a1, a2) => alt b {
twopar::<T>(a1, a2) => match b {
twopar::<T>(b1, b2) => return a1 == b1 && a2 == b2,
_ => return false
}
threepar::<T>(a1, a2, a3) => alt b {
threepar::<T>(a1, a2, a3) => match b {
threepar::<T>(b1, b2, b3) => {
return a1 == b1 && a2 == b2 && a3 == b3
}

8
src/libstd/ebml.rs
View file

@ -113,7 +113,7 @@ fn maybe_get_doc(d: doc, tg: uint) -> option<doc> {
}
fn get_doc(d: doc, tg: uint) -> doc {
alt maybe_get_doc(d, tg) {
match maybe_get_doc(d, tg) {
some(d) => return d,
none => {
error!{"failed to find block with tag %u", tg};
@ -189,7 +189,7 @@ enum writer {
}
fn write_sized_vuint(w: io::writer, n: uint, size: uint) {
alt size {
match size {
1u => w.write(&[0x80u8 | (n as u8)]),
2u => w.write(&[0x40u8 | ((n >> 8_u) as u8), n as u8]),
3u => w.write(&[0x20u8 | ((n >> 16_u) as u8), (n >> 8_u) as u8,
@ -593,7 +593,7 @@ fn test_option_int() {
fn serialize_0<S: serialization::serializer>(s: S, v: option<int>) {
do s.emit_enum(~"core::option::t") {
alt v {
match v {
none => s.emit_enum_variant(
~"core::option::none", 0u, 0u, || { } ),
some(v0) => {
@ -612,7 +612,7 @@ fn test_option_int() {
fn deserialize_0<S: serialization::deserializer>(s: S) -> option<int> {
do s.read_enum(~"core::option::t") {
do s.read_enum_variant |i| {
alt check i {
match check i {
0u => none,
1u => {
let v0 = do s.read_enum_variant_arg(0u) {

6
src/libstd/fun_treemap.rs
View file

@ -30,7 +30,7 @@ fn init<K, V>() -> treemap<K, V> { @empty }
/// Insert a value into the map
fn insert<K: copy, V: copy>(m: treemap<K, V>, k: K, v: V) -> treemap<K, V> {
@alt m {
@match m {
@empty => node(@k, @v, @empty, @empty),
@node(@kk, vv, left, right) => {
if k < kk {
@ -44,7 +44,7 @@ fn insert<K: copy, V: copy>(m: treemap<K, V>, k: K, v: V) -> treemap<K, V> {
/// Find a value based on the key
fn find<K, V: copy>(m: treemap<K, V>, k: K) -> option<V> {
alt *m {
match *m {
empty => none,
node(@kk, @v, left, right) => {
if k == kk {
@ -56,7 +56,7 @@ fn find<K, V: copy>(m: treemap<K, V>, k: K) -> option<V> {
/// Visit all pairs in the map in order.
fn traverse<K, V: copy>(m: treemap<K, V>, f: fn(K, V)) {
alt *m {
match *m {
empty => (),
/*
Previously, this had what looked like redundant

106
src/libstd/getopts.rs
View file

@ -43,7 +43,7 @@
* optflag("h"),
* optflag("help")
* ];
* let matches = alt getopts(vec::tail(args), opts) {
* let matches = match getopts(vec::tail(args), opts) {
* result::ok(m) { m }
* result::err(f) { fail fail_str(f) }
* };
@ -140,7 +140,7 @@ fn is_arg(arg: ~str) -> bool {
}
fn name_str(nm: name) -> ~str {
return alt nm {
return match nm {
short(ch) => str::from_char(ch),
long(s) => s
};
@ -164,7 +164,7 @@ enum fail_ {
/// Convert a `fail_` enum into an error string
fn fail_str(f: fail_) -> ~str {
return alt f {
return match f {
argument_missing(nm) => ~"Argument to option '" + nm + ~"' missing.",
unrecognized_option(nm) => ~"Unrecognized option: '" + nm + ~"'.",
option_missing(nm) => ~"Required option '" + nm + ~"' missing.",
@ -233,12 +233,14 @@ fn getopts(args: ~[~str], opts: ~[opt]) -> result unsafe {
correctly
*/
alt find_opt(opts, opt) {
match find_opt(opts, opt) {
some(id) => last_valid_opt_id = option::some(id),
none => {
let arg_follows =
option::is_some(last_valid_opt_id) &&
alt opts[option::get(last_valid_opt_id)].hasarg {
match opts[option::get(last_valid_opt_id)]
.hasarg {
yes | maybe => true,
no => false
};
@ -257,11 +259,11 @@ fn getopts(args: ~[~str], opts: ~[opt]) -> result unsafe {
let mut name_pos = 0u;
for vec::each(names) |nm| {
name_pos += 1u;
let optid = alt find_opt(opts, nm) {
let optid = match find_opt(opts, nm) {
some(id) => id,
none => return err(unrecognized_option(name_str(nm)))
};
alt opts[optid].hasarg {
match opts[optid].hasarg {
no => {
if !option::is_none::<~str>(i_arg) {
return err(unexpected_argument(name_str(nm)));
@ -309,7 +311,7 @@ fn getopts(args: ~[~str], opts: ~[opt]) -> result unsafe {
}
fn opt_vals(m: matches, nm: ~str) -> ~[optval] {
return alt find_opt(m.opts, mkname(nm)) {
return match find_opt(m.opts, mkname(nm)) {
some(id) => m.vals[id],
none => {
error!{"No option '%s' defined", nm};
@ -328,7 +330,7 @@ fn opt_present(m: matches, nm: ~str) -> bool {
/// Returns true if any of several options were matched
fn opts_present(m: matches, names: ~[~str]) -> bool {
for vec::each(names) |nm| {
alt find_opt(m.opts, mkname(nm)) {
match find_opt(m.opts, mkname(nm)) {
some(_) => return true,
_ => ()
}
@ -344,7 +346,7 @@ fn opts_present(m: matches, names: ~[~str]) -> bool {
* argument
*/
fn opt_str(m: matches, nm: ~str) -> ~str {
return alt opt_val(m, nm) { val(s) => s, _ => fail };
return match opt_val(m, nm) { val(s) => s, _ => fail };
}
/**
@ -355,7 +357,7 @@ fn opt_str(m: matches, nm: ~str) -> ~str {
*/
fn opts_str(m: matches, names: ~[~str]) -> ~str {
for vec::each(names) |nm| {
alt opt_val(m, nm) {
match opt_val(m, nm) {
val(s) => return s,
_ => ()
}
@ -373,7 +375,7 @@ fn opts_str(m: matches, names: ~[~str]) -> ~str {
fn opt_strs(m: matches, nm: ~str) -> ~[~str] {
let mut acc: ~[~str] = ~[];
for vec::each(opt_vals(m, nm)) |v| {
alt v { val(s) => vec::push(acc, s), _ => () }
match v { val(s) => vec::push(acc, s), _ => () }
}
return acc;
}
@ -382,7 +384,7 @@ fn opt_strs(m: matches, nm: ~str) -> ~[~str] {
fn opt_maybe_str(m: matches, nm: ~str) -> option<~str> {
let vals = opt_vals(m, nm);
if vec::len::<optval>(vals) == 0u { return none::<~str>; }
return alt vals[0] { val(s) => some::<~str>(s), _ => none::<~str> };
return match vals[0] { val(s) => some::<~str>(s), _ => none::<~str> };
}
@ -396,7 +398,7 @@ fn opt_maybe_str(m: matches, nm: ~str) -> option<~str> {
fn opt_default(m: matches, nm: ~str, def: ~str) -> option<~str> {
let vals = opt_vals(m, nm);
if vec::len::<optval>(vals) == 0u { return none::<~str>; }
return alt vals[0] { val(s) => some::<~str>(s), _ => some::<~str>(def) }
return match vals[0] { val(s) => some::<~str>(s), _ => some::<~str>(def) }
}
#[cfg(test)]
@ -413,7 +415,7 @@ mod tests {
}
fn check_fail_type(f: fail_, ft: fail_type) {
alt f {
match f {
argument_missing(_) => assert ft == argument_missing_,
unrecognized_option(_) => assert ft == unrecognized_option_,
option_missing(_) => assert ft == option_missing_,
@ -429,7 +431,7 @@ mod tests {
let args = ~[~"--test=20"];
let opts = ~[reqopt(~"test")];
let rs = getopts(args, opts);
alt check rs {
match check rs {
ok(m) => {
assert (opt_present(m, ~"test"));
assert (opt_str(m, ~"test") == ~"20");
@ -442,7 +444,7 @@ mod tests {
let args = ~[~"blah"];
let opts = ~[reqopt(~"test")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => check_fail_type(f, option_missing_),
_ => fail
}
@ -453,7 +455,7 @@ mod tests {
let args = ~[~"--test"];
let opts = ~[reqopt(~"test")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => check_fail_type(f, argument_missing_),
_ => fail
}
@ -464,7 +466,7 @@ mod tests {
let args = ~[~"--test=20", ~"--test=30"];
let opts = ~[reqopt(~"test")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => check_fail_type(f, option_duplicated_),
_ => fail
}
@ -475,7 +477,7 @@ mod tests {
let args = ~[~"-t", ~"20"];
let opts = ~[reqopt(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => {
assert (opt_present(m, ~"t"));
assert (opt_str(m, ~"t") == ~"20");
@ -489,7 +491,7 @@ mod tests {
let args = ~[~"blah"];
let opts = ~[reqopt(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => check_fail_type(f, option_missing_),
_ => fail
}
@ -500,7 +502,7 @@ mod tests {
let args = ~[~"-t"];
let opts = ~[reqopt(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => check_fail_type(f, argument_missing_),
_ => fail
}
@ -511,7 +513,7 @@ mod tests {
let args = ~[~"-t", ~"20", ~"-t", ~"30"];
let opts = ~[reqopt(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => check_fail_type(f, option_duplicated_),
_ => fail
}
@ -524,7 +526,7 @@ mod tests {
let args = ~[~"--test=20"];
let opts = ~[optopt(~"test")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => {
assert (opt_present(m, ~"test"));
assert (opt_str(m, ~"test") == ~"20");
@ -538,7 +540,7 @@ mod tests {
let args = ~[~"blah"];
let opts = ~[optopt(~"test")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => assert (!opt_present(m, ~"test")),
_ => fail
}
@ -549,7 +551,7 @@ mod tests {
let args = ~[~"--test"];
let opts = ~[optopt(~"test")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => check_fail_type(f, argument_missing_),
_ => fail
}
@ -560,7 +562,7 @@ mod tests {
let args = ~[~"--test=20", ~"--test=30"];
let opts = ~[optopt(~"test")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => check_fail_type(f, option_duplicated_),
_ => fail
}
@ -571,7 +573,7 @@ mod tests {
let args = ~[~"-t", ~"20"];
let opts = ~[optopt(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => {
assert (opt_present(m, ~"t"));
assert (opt_str(m, ~"t") == ~"20");
@ -585,7 +587,7 @@ mod tests {
let args = ~[~"blah"];
let opts = ~[optopt(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => assert (!opt_present(m, ~"t")),
_ => fail
}
@ -596,7 +598,7 @@ mod tests {
let args = ~[~"-t"];
let opts = ~[optopt(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => check_fail_type(f, argument_missing_),
_ => fail
}
@ -607,7 +609,7 @@ mod tests {
let args = ~[~"-t", ~"20", ~"-t", ~"30"];
let opts = ~[optopt(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => check_fail_type(f, option_duplicated_),
_ => fail
}
@ -620,7 +622,7 @@ mod tests {
let args = ~[~"--test"];
let opts = ~[optflag(~"test")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => assert (opt_present(m, ~"test")),
_ => fail
}
@ -631,7 +633,7 @@ mod tests {
let args = ~[~"blah"];
let opts = ~[optflag(~"test")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => assert (!opt_present(m, ~"test")),
_ => fail
}
@ -642,7 +644,7 @@ mod tests {
let args = ~[~"--test=20"];
let opts = ~[optflag(~"test")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => {
log(error, fail_str(f));
check_fail_type(f, unexpected_argument_);
@ -656,7 +658,7 @@ mod tests {
let args = ~[~"--test", ~"--test"];
let opts = ~[optflag(~"test")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => check_fail_type(f, option_duplicated_),
_ => fail
}
@ -667,7 +669,7 @@ mod tests {
let args = ~[~"-t"];
let opts = ~[optflag(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => assert (opt_present(m, ~"t")),
_ => fail
}
@ -678,7 +680,7 @@ mod tests {
let args = ~[~"blah"];
let opts = ~[optflag(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => assert (!opt_present(m, ~"t")),
_ => fail
}
@ -689,7 +691,7 @@ mod tests {
let args = ~[~"-t", ~"20"];
let opts = ~[optflag(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => {
// The next variable after the flag is just a free argument
@ -704,7 +706,7 @@ mod tests {
let args = ~[~"-t", ~"-t"];
let opts = ~[optflag(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => check_fail_type(f, option_duplicated_),
_ => fail
}
@ -717,7 +719,7 @@ mod tests {
let args = ~[~"--test=20"];
let opts = ~[optmulti(~"test")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => {
assert (opt_present(m, ~"test"));
assert (opt_str(m, ~"test") == ~"20");
@ -731,7 +733,7 @@ mod tests {
let args = ~[~"blah"];
let opts = ~[optmulti(~"test")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => assert (!opt_present(m, ~"test")),
_ => fail
}
@ -742,7 +744,7 @@ mod tests {
let args = ~[~"--test"];
let opts = ~[optmulti(~"test")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => check_fail_type(f, argument_missing_),
_ => fail
}
@ -753,7 +755,7 @@ mod tests {
let args = ~[~"--test=20", ~"--test=30"];
let opts = ~[optmulti(~"test")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => {
assert (opt_present(m, ~"test"));
assert (opt_str(m, ~"test") == ~"20");
@ -769,7 +771,7 @@ mod tests {
let args = ~[~"-t", ~"20"];
let opts = ~[optmulti(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => {
assert (opt_present(m, ~"t"));
assert (opt_str(m, ~"t") == ~"20");
@ -783,7 +785,7 @@ mod tests {
let args = ~[~"blah"];
let opts = ~[optmulti(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => assert (!opt_present(m, ~"t")),
_ => fail
}
@ -794,7 +796,7 @@ mod tests {
let args = ~[~"-t"];
let opts = ~[optmulti(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => check_fail_type(f, argument_missing_),
_ => fail
}
@ -805,7 +807,7 @@ mod tests {
let args = ~[~"-t", ~"20", ~"-t", ~"30"];
let opts = ~[optmulti(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => {
assert (opt_present(m, ~"t"));
assert (opt_str(m, ~"t") == ~"20");
@ -821,7 +823,7 @@ mod tests {
let args = ~[~"--untest"];
let opts = ~[optmulti(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => check_fail_type(f, unrecognized_option_),
_ => fail
}
@ -832,7 +834,7 @@ mod tests {
let args = ~[~"-t"];
let opts = ~[optmulti(~"test")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => check_fail_type(f, unrecognized_option_),
_ => fail
}
@ -849,7 +851,7 @@ mod tests {
optflag(~"f"), optmulti(~"m"), optmulti(~"n"),
optopt(~"notpresent")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => {
assert (m.free[0] == ~"prog");
assert (m.free[1] == ~"free1");
@ -872,7 +874,7 @@ mod tests {
fn test_multi() {
let args = ~[~"-e", ~"foo", ~"--encrypt", ~"foo"];
let opts = ~[optopt(~"e"), optopt(~"encrypt")];
let matches = alt getopts(args, opts) {
let matches = match getopts(args, opts) {
result::ok(m) => m,
result::err(f) => fail
};
@ -893,7 +895,7 @@ mod tests {
fn test_nospace() {
let args = ~[~"-Lfoo"];
let opts = ~[optmulti(~"L")];
let matches = alt getopts(args, opts) {
let matches = match getopts(args, opts) {
result::ok(m) => m,
result::err(f) => fail
};

56
src/libstd/json.rs
View file

@ -45,7 +45,7 @@ type error = {
/// Serializes a json value into a io::writer
fn to_writer(wr: io::writer, j: json) {
alt j {
match j {
num(n) => wr.write_str(float::to_str(n, 6u)),
string(s) => wr.write_str(escape_str(*s)),
boolean(b) => wr.write_str(if b { ~"true" } else { ~"false" }),
@ -87,7 +87,7 @@ fn to_writer(wr: io::writer, j: json) {
fn escape_str(s: ~str) -> ~str {
let mut escaped = ~"\"";
do str::chars_iter(s) |c| {
alt c {
match c {
'"' => escaped += ~"\\\"",
'\\' => escaped += ~"\\\\",
'\x08' => escaped += ~"\\b",
@ -144,7 +144,7 @@ impl parser for parser {
}
fn parse() -> result<json, error> {
alt self.parse_value() {
match self.parse_value() {
ok(value) => {
// Skip trailing whitespaces.
self.parse_whitespace();
@ -164,12 +164,12 @@ impl parser for parser {
if self.eof() { return self.error(~"EOF while parsing value"); }
alt self.ch {
match self.ch {
'n' => self.parse_ident(~"ull", null),
't' => self.parse_ident(~"rue", boolean(true)),
'f' => self.parse_ident(~"alse", boolean(false)),
'0' to '9' | '-' => self.parse_number(),
'"' => alt self.parse_str() {
'"' => match self.parse_str() {
ok(s) => ok(string(s)),
err(e) => err(e)
}
@ -200,20 +200,20 @@ impl parser for parser {
neg = -1f;
}
let mut res = alt self.parse_integer() {
let mut res = match self.parse_integer() {
ok(res) => res,
err(e) => return err(e)
};
if self.ch == '.' {
alt self.parse_decimal(res) {
match self.parse_decimal(res) {
ok(r) => res = r,
err(e) => return err(e)
}
}
if self.ch == 'e' || self.ch == 'E' {
alt self.parse_exponent(res) {
match self.parse_exponent(res) {
ok(r) => res = r,
err(e) => return err(e)
}
@ -225,19 +225,19 @@ impl parser for parser {
fn parse_integer() -> result<float, error> {
let mut res = 0f;
alt self.ch {
match self.ch {
'0' => {
self.bump();
// There can be only one leading '0'.
alt self.ch {
match self.ch {
'0' to '9' => return self.error(~"invalid number"),
_ => ()
}
}
'1' to '9' => {
while !self.eof() {
alt self.ch {
match self.ch {
'0' to '9' => {
res *= 10f;
res += ((self.ch as int) - ('0' as int)) as float;
@ -258,7 +258,7 @@ impl parser for parser {
self.bump();
// Make sure a digit follows the decimal place.
alt self.ch {
match self.ch {
'0' to '9' => (),
_ => return self.error(~"invalid number")
}
@ -266,7 +266,7 @@ impl parser for parser {
let mut res = res;
let mut dec = 1f;
while !self.eof() {
alt self.ch {
match self.ch {
'0' to '9' => {
dec /= 10f;
res += (((self.ch as int) - ('0' as int)) as float) * dec;
@ -287,20 +287,20 @@ impl parser for parser {
let mut exp = 0u;
let mut neg_exp = false;
alt self.ch {
match self.ch {
'+' => self.bump(),
'-' => { self.bump(); neg_exp = true; }
_ => ()
}
// Make sure a digit follows the exponent place.
alt self.ch {
match self.ch {
'0' to '9' => (),
_ => return self.error(~"invalid number")
}
while !self.eof() {
alt self.ch {
match self.ch {
'0' to '9' => {
exp *= 10u;
exp += (self.ch as uint) - ('0' as uint);
@ -329,7 +329,7 @@ impl parser for parser {
self.bump();
if (escape) {
alt self.ch {
match self.ch {
'"' => str::push_char(res, '"'),
'\\' => str::push_char(res, '\\'),
'/' => str::push_char(res, '/'),
@ -343,7 +343,7 @@ impl parser for parser {
let mut i = 0u;
let mut n = 0u;
while i < 4u {
alt self.next_char() {
match self.next_char() {
'0' to '9' => {
n = n * 10u +
(self.ch as uint) - ('0' as uint);
@ -389,7 +389,7 @@ impl parser for parser {
}
loop {
alt self.parse_value() {
match self.parse_value() {
ok(v) => vec::push(values, v),
e => return e
}
@ -399,7 +399,7 @@ impl parser for parser {
return self.error(~"EOF while parsing list");
}
alt self.ch {
match self.ch {
',' => self.bump(),
']' => { self.bump(); return ok(list(@values)); }
_ => return self.error(~"expected `,` or `]`")
@ -425,7 +425,7 @@ impl parser for parser {
return self.error(~"key must be a string");
}
let key = alt self.parse_str() {
let key = match self.parse_str() {
ok(key) => key,
err(e) => return err(e)
};
@ -438,13 +438,13 @@ impl parser for parser {
}
self.bump();
alt self.parse_value() {
match self.parse_value() {
ok(value) => { values.insert(copy *key, value); }
e => return e
}
self.parse_whitespace();
alt self.ch {
match self.ch {
',' => self.bump(),
'}' => { self.bump(); return ok(dict(values)); }
_ => {
@ -477,7 +477,7 @@ fn from_str(s: ~str) -> result<json, error> {
/// Test if two json values are equal
fn eq(value0: json, value1: json) -> bool {
alt (value0, value1) {
match (value0, value1) {
(num(f0), num(f1)) => f0 == f1,
(string(s0), string(s1)) => s0 == s1,
(boolean(b0), boolean(b1)) => b0 == b1,
@ -486,7 +486,7 @@ fn eq(value0: json, value1: json) -> bool {
if d0.size() == d1.size() {
let mut equal = true;
for d0.each |k, v0| {
alt d1.find(k) {
match d1.find(k) {
some(v1) => if !eq(v0, v1) { equal = false },
none => equal = false
}
@ -581,7 +581,7 @@ impl of to_json for @~str {
impl <A: to_json, B: to_json> of to_json for (A, B) {
fn to_json() -> json {
alt self {
match self {
(a, b) => {
list(@~[a.to_json(), b.to_json()])
}
@ -592,7 +592,7 @@ impl <A: to_json, B: to_json> of to_json for (A, B) {
impl <A: to_json, B: to_json, C: to_json>
of to_json for (A, B, C) {
fn to_json() -> json {
alt self {
match self {
(a, b, c) => {
list(@~[a.to_json(), b.to_json(), c.to_json()])
}
@ -616,7 +616,7 @@ impl <A: to_json copy> of to_json for hashmap<~str, A> {
impl <A: to_json> of to_json for option<A> {
fn to_json() -> json {
alt self {
match self {
none => null,
some(value) => value.to_json()
}

14
src/libstd/list.rs
View file

@ -43,7 +43,7 @@ fn foldl<T: copy, U>(z: T, ls: @list<U>, f: fn(T, U) -> T) -> T {
fn find<T: copy>(ls: @list<T>, f: fn(T) -> bool) -> option<T> {
let mut ls = ls;
loop {
ls = alt *ls {
ls = match *ls {
cons(hd, tl) => {
if f(hd) { return some(hd); }
tl
@ -63,7 +63,7 @@ fn has<T: copy>(ls: @list<T>, elt: T) -> bool {
/// Returns true if the list is empty
pure fn is_empty<T: copy>(ls: @list<T>) -> bool {
alt *ls {
match *ls {
nil => true,
_ => false
}
@ -83,7 +83,7 @@ fn len<T>(ls: @list<T>) -> uint {
/// Returns all but the first element of a list
pure fn tail<T: copy>(ls: @list<T>) -> @list<T> {
alt *ls {
match *ls {
cons(_, tl) => return tl,
nil => fail ~"list empty"
}
@ -91,12 +91,12 @@ pure fn tail<T: copy>(ls: @list<T>) -> @list<T> {
/// Returns the first element of a list
pure fn head<T: copy>(ls: @list<T>) -> T {
alt check *ls { cons(hd, _) => hd }
match check *ls { cons(hd, _) => hd }
}
/// Appends one list to another
pure fn append<T: copy>(l: @list<T>, m: @list<T>) -> @list<T> {
alt *l {
match *l {
nil => return m,
cons(x, xs) => {
let rest = append(xs, m);
@ -114,7 +114,7 @@ fn push<T: copy>(&l: list<T>, v: T) {
fn iter<T>(l: @list<T>, f: fn(T)) {
let mut cur = l;
loop {
cur = alt *cur {
cur = match *cur {
cons(hd, tl) => {
f(hd);
tl
@ -128,7 +128,7 @@ fn iter<T>(l: @list<T>, f: fn(T)) {
fn each<T>(l: @list<T>, f: fn(T) -> bool) {
let mut cur = l;
loop {
cur = alt *cur {
cur = match *cur {
cons(hd, tl) => {
if !f(hd) { return; }
tl

16
src/libstd/map.rs
View file

@ -133,7 +133,7 @@ mod chained {
let mut e0 = e_root;
let mut comp = 1u; // for logging
loop {
alt copy e0.next {
match copy e0.next {
none => {
debug!{"search_tbl: absent, comp %u, hash %u, idx %u",
comp, h, idx};
@ -156,7 +156,7 @@ mod chained {
fn search_tbl(k: &K, h: uint) -> search_result<K,V> {
let idx = h % vec::len(self.chains);
alt copy self.chains[idx] {
match copy self.chains[idx] {
none => {
debug!{"search_tbl: none, comp %u, hash %u, idx %u",
0u, h, idx};
@ -193,7 +193,7 @@ mod chained {
while i < n {
let mut chain = self.chains[i];
loop {
chain = alt chain {
chain = match chain {
none => break,
some(entry) => {
let next = entry.next;
@ -216,7 +216,7 @@ mod chained {
fn contains_key_ref(k: &K) -> bool {
let hash = self.hasher(k);
alt self.search_tbl(k, hash) {
match self.search_tbl(k, hash) {
not_found => false,
found_first(*) | found_after(*) => true
}
@ -224,7 +224,7 @@ mod chained {
fn insert(+k: K, +v: V) -> bool {
let hash = self.hasher(&k);
alt self.search_tbl(&k, hash) {
match self.search_tbl(&k, hash) {
not_found => {
self.count += 1u;
let idx = hash % vec::len(self.chains);
@ -265,7 +265,7 @@ mod chained {
}
fn find(+k: K) -> option<V> {
alt self.search_tbl(&k, self.hasher(&k)) {
match self.search_tbl(&k, self.hasher(&k)) {
not_found => none,
found_first(_, entry) => some(entry.value),
found_after(_, entry) => some(entry.value)
@ -281,7 +281,7 @@ mod chained {
}
fn remove(+k: K) -> option<V> {
alt self.search_tbl(&k, self.hasher(&k)) {
match self.search_tbl(&k, self.hasher(&k)) {
not_found => none,
found_first(idx, entry) => {
self.count -= 1u;
@ -638,7 +638,7 @@ mod tests {
i = 0u;
while i < num_to_insert {
let v = hm.remove(i);
alt v {
match v {
option::some(u) => assert (u == i * i),
option::none => fail
}

16
src/libstd/net_ip.rs
View file

@ -47,7 +47,7 @@ type parse_addr_err = {
* * ip - a `std::net::ip::ip_addr`
*/
fn format_addr(ip: ip_addr) -> ~str {
alt ip {
match ip {
ipv4(addr) => unsafe {
let result = uv_ip4_name(&addr);
if result == ~"" {
@ -103,7 +103,7 @@ fn get_addr(++node: ~str, iotask: iotask)
node_ptr,
ptr::null(),
ptr::null());
alt result {
match result {
0i32 => {
set_data_for_req(handle_ptr, handle_data_ptr);
}
@ -134,7 +134,7 @@ mod v4 {
* * an `ip_addr` of the `ipv4` variant
*/
fn parse_addr(ip: ~str) -> ip_addr {
alt try_parse_addr(ip) {
match try_parse_addr(ip) {
result::ok(addr) => copy(addr),
result::err(err_data) => fail err_data.err_msg
}
@ -155,7 +155,7 @@ mod v4 {
}
fn parse_to_ipv4_rep(ip: ~str) -> result::result<ipv4_rep, ~str> {
let parts = vec::map(str::split_char(ip, '.'), |s| {
alt uint::from_str(s) {
match uint::from_str(s) {
some(n) if n <= 255u => n,
_ => 256u
}
@ -220,7 +220,7 @@ mod v6 {
* * an `ip_addr` of the `ipv6` variant
*/
fn parse_addr(ip: ~str) -> ip_addr {
alt try_parse_addr(ip) {
match try_parse_addr(ip) {
result::ok(addr) => copy(addr),
result::err(err_data) => fail err_data.err_msg
}
@ -326,7 +326,7 @@ mod test {
}
#[test]
fn test_ip_ipv4_bad_parse() {
alt v4::try_parse_addr(~"b4df00d") {
match v4::try_parse_addr(~"b4df00d") {
result::err(err_info) => {
log(debug, fmt!{"got error as expected %?", err_info});
assert true;
@ -339,7 +339,7 @@ mod test {
#[test]
#[ignore(target_os="win32")]
fn test_ip_ipv6_bad_parse() {
alt v6::try_parse_addr(~"::,~2234k;") {
match v6::try_parse_addr(~"::,~2234k;") {
result::err(err_info) => {
log(debug, fmt!{"got error as expected %?", err_info});
assert true;
@ -364,7 +364,7 @@ mod test {
log(debug, fmt!{"test_get_addr: Number of results for %s: %?",
localhost_name, vec::len(results)});
for vec::each(results) |r| {
let ipv_prefix = alt r {
let ipv_prefix = match r {
ipv4(_) => ~"IPv4",
ipv6(_) => ~"IPv6"
};

66
src/libstd/net_tcp.rs
View file

@ -151,16 +151,16 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
log(debug, ~"in interact cb for tcp client connect..");
log(debug, fmt!{"stream_handle_ptr in interact %?",
stream_handle_ptr});
alt uv::ll::tcp_init( loop_ptr, stream_handle_ptr) {
match uv::ll::tcp_init( loop_ptr, stream_handle_ptr) {
0i32 => {
log(debug, ~"tcp_init successful");
alt input_ip {
match input_ip {
ipv4 => {
log(debug, ~"dealing w/ ipv4 connection..");
let connect_req_ptr =
ptr::addr_of((*socket_data_ptr).connect_req);
let addr_str = ip::format_addr(input_ip);
let connect_result = alt input_ip {
let connect_result = match input_ip {
ip::ipv4(addr) => {
// have to "recreate" the sockaddr_in/6
// since the ip_addr discards the port
@ -185,7 +185,7 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
tcp_connect_on_connect_cb)
}
};
alt connect_result {
match connect_result {
0i32 => {
log(debug, ~"tcp_connect successful");
// reusable data that we'll have for the
@ -223,7 +223,7 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
}
}
};
alt comm::recv(result_po) {
match comm::recv(result_po) {
conn_success => {
log(debug, ~"tcp::connect - received success on result_po");
result::ok(tcp_socket(socket_data))
@ -234,7 +234,7 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
// still have to free the malloc'd stream handle..
rustrt::rust_uv_current_kernel_free(stream_handle_ptr
as *libc::c_void);
let tcp_conn_err = alt err_data.err_name {
let tcp_conn_err = match err_data.err_name {
~"ECONNREFUSED" => connection_refused,
_ => generic_connect_err(err_data.err_name, err_data.err_msg)
};
@ -445,7 +445,7 @@ fn read_future(sock: tcp_socket, timeout_msecs: uint)
* // do work here
* }
* };
* alt comm::recv(cont_po) {
* match comm::recv(cont_po) {
* // shut down listen()
* some(err_data) { comm::send(kill_chan, some(err_data)) }
* // wait for next connection
@ -469,7 +469,7 @@ fn read_future(sock: tcp_socket, timeout_msecs: uint)
fn accept(new_conn: tcp_new_connection)
-> result::result<tcp_socket, tcp_err_data> unsafe {
alt new_conn{
match new_conn{
new_tcp_conn(server_handle_ptr) => {
let server_data_ptr = uv::ll::get_data_for_uv_handle(
server_handle_ptr) as *tcp_listen_fc_data;
@ -501,10 +501,10 @@ fn accept(new_conn: tcp_new_connection)
log(debug, ~"in interact cb for tcp::accept");
let loop_ptr = uv::ll::get_loop_for_uv_handle(
server_handle_ptr);
alt uv::ll::tcp_init(loop_ptr, client_stream_handle_ptr) {
match uv::ll::tcp_init(loop_ptr, client_stream_handle_ptr) {
0i32 => {
log(debug, ~"uv_tcp_init successful for client stream");
alt uv::ll::accept(
match uv::ll::accept(
server_handle_ptr as *libc::c_void,
client_stream_handle_ptr as *libc::c_void) {
0i32 => {
@ -528,7 +528,7 @@ fn accept(new_conn: tcp_new_connection)
}
}
// UNSAFE LIBUV INTERACTION END
alt comm::recv(result_po) {
match comm::recv(result_po) {
some(err_data) => result::err(err_data),
none => result::ok(tcp_socket(client_socket_data))
}
@ -610,13 +610,13 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
// nested within a comm::listen block)
let loc_ip = copy(host_ip);
do iotask::interact(iotask) |loop_ptr| {
alt uv::ll::tcp_init(loop_ptr, server_stream_ptr) {
match uv::ll::tcp_init(loop_ptr, server_stream_ptr) {
0i32 => {
uv::ll::set_data_for_uv_handle(
server_stream_ptr,
server_data_ptr);
let addr_str = ip::format_addr(loc_ip);
let bind_result = alt loc_ip {
let bind_result = match loc_ip {
ip::ipv4(addr) => {
log(debug, fmt!{"addr: %?", addr});
let in_addr = uv::ll::ip4_addr(addr_str, port as int);
@ -630,9 +630,9 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
ptr::addr_of(in_addr))
}
};
alt bind_result {
match bind_result {
0i32 => {
alt uv::ll::listen(server_stream_ptr,
match uv::ll::listen(server_stream_ptr,
backlog as libc::c_int,
tcp_lfc_on_connection_cb) {
0i32 => comm::send(setup_ch, none),
@ -659,7 +659,7 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
};
setup_ch.recv()
};
alt setup_result {
match setup_result {
some(err_data) => {
do iotask::interact(iotask) |loop_ptr| {
log(debug, fmt!{"tcp::listen post-kill recv hl interact %?",
@ -668,7 +668,7 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
uv::ll::close(server_stream_ptr, tcp_lfc_close_cb);
};
stream_closed_po.recv();
alt err_data.err_name {
match err_data.err_name {
~"EACCES" => {
log(debug, ~"Got EACCES error");
result::err(access_denied)
@ -695,7 +695,7 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
uv::ll::close(server_stream_ptr, tcp_lfc_close_cb);
};
stream_closed_po.recv();
alt kill_result {
match kill_result {
// some failure post bind/listen
some(err_data) => result::err(generic_listen_err(err_data.err_name,
err_data.err_msg)),
@ -878,7 +878,7 @@ fn read_common_impl(socket_data: *tcp_socket_data, timeout_msecs: uint)
some(comm::recv(result::get(rs_result)))
};
log(debug, ~"tcp::read after recv_timeout");
alt read_result {
match read_result {
none => {
log(debug, ~"tcp::read: timed out..");
let err_data = {
@ -905,7 +905,7 @@ fn read_stop_common_impl(socket_data: *tcp_socket_data) ->
let stop_ch = comm::chan(stop_po);
do iotask::interact((*socket_data).iotask) |loop_ptr| {
log(debug, ~"in interact cb for tcp::read_stop");
alt uv::ll::read_stop(stream_handle_ptr as *uv::ll::uv_stream_t) {
match uv::ll::read_stop(stream_handle_ptr as *uv::ll::uv_stream_t) {
0i32 => {
log(debug, ~"successfully called uv_read_stop");
comm::send(stop_ch, none);
@ -917,7 +917,7 @@ fn read_stop_common_impl(socket_data: *tcp_socket_data) ->
}
}
};
alt comm::recv(stop_po) {
match comm::recv(stop_po) {
some(err_data) => result::err(err_data.to_tcp_err()),
none => result::ok(())
}
@ -933,7 +933,7 @@ fn read_start_common_impl(socket_data: *tcp_socket_data)
log(debug, ~"in tcp::read_start before interact loop");
do iotask::interact((*socket_data).iotask) |loop_ptr| {
log(debug, fmt!{"in tcp::read_start interact cb %?", loop_ptr});
alt uv::ll::read_start(stream_handle_ptr as *uv::ll::uv_stream_t,
match uv::ll::read_start(stream_handle_ptr as *uv::ll::uv_stream_t,
on_alloc_cb,
on_tcp_read_cb) {
0i32 => {
@ -947,7 +947,7 @@ fn read_start_common_impl(socket_data: *tcp_socket_data)
}
}
};
alt comm::recv(start_po) {
match comm::recv(start_po) {
some(err_data) => result::err(err_data.to_tcp_err()),
none => result::ok((*socket_data).reader_po)
}
@ -973,7 +973,7 @@ fn write_common_impl(socket_data_ptr: *tcp_socket_data,
let write_data_ptr = ptr::addr_of(write_data);
do iotask::interact((*socket_data_ptr).iotask) |loop_ptr| {
log(debug, fmt!{"in interact cb for tcp::write %?", loop_ptr});
alt uv::ll::write(write_req_ptr,
match uv::ll::write(write_req_ptr,
stream_handle_ptr,
write_buf_vec_ptr,
tcp_write_complete_cb) {
@ -993,7 +993,7 @@ fn write_common_impl(socket_data_ptr: *tcp_socket_data,
// and waiting here for the write to complete, we should transfer
// ownership of everything to the I/O task and let it deal with the
// aftermath, so we don't have to sit here blocking.
alt comm::recv(result_po) {
match comm::recv(result_po) {
tcp_write_success => result::ok(()),
tcp_write_error(err_data) => result::err(err_data.to_tcp_err())
}
@ -1024,7 +1024,7 @@ extern fn tcp_lfc_on_connection_cb(handle: *uv::ll::uv_tcp_t,
as *tcp_listen_fc_data;
let kill_ch = (*server_data_ptr).kill_ch;
if (*server_data_ptr).active {
alt status {
match status {
0i32 => (*server_data_ptr).on_connect_cb(handle),
_ => {
let loop_ptr = uv::ll::get_loop_for_uv_handle(handle);
@ -1081,7 +1081,7 @@ extern fn on_tcp_read_cb(stream: *uv::ll::uv_stream_t,
let loop_ptr = uv::ll::get_loop_for_uv_handle(stream);
let socket_data_ptr = uv::ll::get_data_for_uv_handle(stream)
as *tcp_socket_data;
alt nread as int {
match nread as int {
// incoming err.. probably eof
-1 => {
let err_data = uv::ll::get_last_err_data(loop_ptr).to_tcp_err();
@ -1175,7 +1175,7 @@ extern fn tcp_connect_on_connect_cb(connect_req_ptr: *uv::ll::uv_connect_t,
log(debug, fmt!{"tcp_connect result_ch %?", result_ch});
let tcp_stream_ptr =
uv::ll::get_stream_handle_from_connect_req(connect_req_ptr);
alt status {
match status {
0i32 => {
log(debug, ~"successful tcp connection!");
comm::send(result_ch, conn_success);
@ -1336,7 +1336,7 @@ mod test {
client_ch,
hl_loop)
};
alt actual_resp_result.get_err() {
match actual_resp_result.get_err() {
connection_refused => (),
_ => fail ~"unknown error.. expected connection_refused"
}
@ -1382,7 +1382,7 @@ mod test {
client_ch,
hl_loop)
};
alt listen_err {
match listen_err {
address_in_use => {
assert true;
}
@ -1401,7 +1401,7 @@ mod test {
server_ip,
server_port,
hl_loop);
alt listen_err {
match listen_err {
access_denied => {
assert true;
}
@ -1515,7 +1515,7 @@ mod test {
log(debug, ~"SERVER: successfully accepted"+
~"connection!");
let received_req_bytes = read(sock, 0u);
alt received_req_bytes {
match received_req_bytes {
result::ok(data) => {
log(debug, ~"SERVER: got REQ str::from_bytes..");
log(debug, fmt!{"SERVER: REQ data len: %?",
@ -1544,7 +1544,7 @@ mod test {
});
// err check on listen_result
if result::is_err(listen_result) {
alt result::get_err(listen_result) {
match result::get_err(listen_result) {
generic_listen_err(name, msg) => {
fail fmt!{"SERVER: exited abnormally name %s msg %s",
name, msg};

72
src/libstd/rope.rs
View file

@ -133,10 +133,10 @@ fn prepend_str(rope: rope, str: @~str) -> rope {
/// Concatenate two ropes
fn append_rope(left: rope, right: rope) -> rope {
alt(left) {
match (left) {
node::empty => return right,
node::content(left_content) => {
alt(right) {
match (right) {
node::empty => return left,
node::content(right_content) => {
return node::content(node::concat2(left_content, right_content));
@ -197,9 +197,9 @@ Section: Keeping ropes healthy
* to rebalance your rope at some point, before using it for other purposes.
*/
fn bal(rope:rope) -> rope {
alt(rope) {
match (rope) {
node::empty => return rope,
node::content(x) => alt(node::bal(x)) {
node::content(x) => match (node::bal(x)) {
option::none => rope,
option::some(y) => node::content(y)
}
@ -226,7 +226,7 @@ Section: Transforming ropes
*/
fn sub_chars(rope: rope, char_offset: uint, char_len: uint) -> rope {
if char_len == 0u { return node::empty; }
alt(rope) {
match (rope) {
node::empty => fail,
node::content(node) => if char_len > node::char_len(node) {
fail
@ -251,7 +251,7 @@ fn sub_chars(rope: rope, char_offset: uint, char_len: uint) -> rope {
*/
fn sub_bytes(rope: rope, byte_offset: uint, byte_len: uint) -> rope {
if byte_len == 0u { return node::empty; }
alt(rope) {
match (rope) {
node::empty => fail,
node::content(node) =>if byte_len > node::byte_len(node) {
fail
@ -276,7 +276,7 @@ Section: Comparing ropes
* value if `left > right`
*/
fn cmp(left: rope, right: rope) -> int {
alt((left, right)) {
match ((left, right)) {
(node::empty, node::empty) => return 0,
(node::empty, _) => return -1,
(_, node::empty) => return 1,
@ -379,7 +379,7 @@ Section: Iterating
* that is if `it` returned `false` at any point.
*/
fn loop_chars(rope: rope, it: fn(char) -> bool) -> bool {
alt(rope) {
match (rope) {
node::empty => return true,
node::content(x) => return node::loop_chars(x, it)
}
@ -422,7 +422,7 @@ fn iter_chars(rope: rope, it: fn(char)) {
* that is if `it` returned `false` at any point.
*/
fn loop_leaves(rope: rope, it: fn(node::leaf) -> bool) -> bool{
alt(rope) {
match (rope) {
node::empty => return true,
node::content(x) => return node::loop_leaves(x, it)
}
@ -431,7 +431,7 @@ fn loop_leaves(rope: rope, it: fn(node::leaf) -> bool) -> bool{
mod iterator {
mod leaf {
fn start(rope: rope) -> node::leaf_iterator::t {
alt(rope) {
match (rope) {
node::empty => return node::leaf_iterator::empty(),
node::content(x) => return node::leaf_iterator::start(x)
}
@ -442,7 +442,7 @@ mod iterator {
}
mod char {
fn start(rope: rope) -> node::char_iterator::t {
alt(rope) {
match (rope) {
node::empty => return node::char_iterator::empty(),
node::content(x) => return node::char_iterator::start(x)
}
@ -469,7 +469,7 @@ mod iterator {
* Constant time.
*/
fn height(rope: rope) -> uint {
alt(rope) {
match (rope) {
node::empty => return 0u,
node::content(x) => return node::height(x)
}
@ -485,7 +485,7 @@ fn height(rope: rope) -> uint {
* Constant time.
*/
pure fn char_len(rope: rope) -> uint {
alt(rope) {
match (rope) {
node::empty => return 0u,
node::content(x) => return node::char_len(x)
}
@ -499,7 +499,7 @@ pure fn char_len(rope: rope) -> uint {
* Constant time.
*/
pure fn byte_len(rope: rope) -> uint {
alt(rope) {
match (rope) {
node::empty => return 0u,
node::content(x) => return node::byte_len(x)
}
@ -522,7 +522,7 @@ pure fn byte_len(rope: rope) -> uint {
* rope + the (bounded) length of the largest leaf.
*/
fn char_at(rope: rope, pos: uint) -> char {
alt(rope) {
match (rope) {
node::empty => fail,
node::content(x) => return node::char_at(x, pos)
}
@ -730,14 +730,14 @@ mod node {
pure fn byte_len(node: @node) -> uint {
//FIXME (#2744): Could we do this without the pattern-matching?
alt(*node) {
match (*node) {
leaf(y) => return y.byte_len,
concat(y) => return y.byte_len
}
}
pure fn char_len(node: @node) -> uint {
alt(*node) {
match (*node) {
leaf(y) => return y.char_len,
concat(y) => return y.char_len
}
@ -800,7 +800,7 @@ mod node {
let mut offset = 0u;//Current position in the buffer
let it = leaf_iterator::start(node);
loop {
alt(leaf_iterator::next(it)) {
match (leaf_iterator::next(it)) {
option::none => break,
option::some(x) => {
//FIXME (#2744): Replace with memcpy or something similar
@ -827,7 +827,7 @@ mod node {
* This function executes in linear time.
*/
fn flatten(node: @node) -> @node unsafe {
alt(*node) {
match (*node) {
leaf(_) => return node,
concat(x) => {
return @leaf({
@ -861,7 +861,7 @@ mod node {
let mut forest = ~[mut];
let it = leaf_iterator::start(node);
loop {
alt (leaf_iterator::next(it)) {
match (leaf_iterator::next(it)) {
option::none => break,
option::some(x) => vec::push(forest, @leaf(x))
}
@ -898,7 +898,7 @@ mod node {
if byte_offset == 0u && byte_len == node::byte_len(node) {
return node;
}
alt(*node) {
match (*node) {
node::leaf(x) => {
let char_len =
str::count_chars(*x.content, byte_offset, byte_len);
@ -956,7 +956,7 @@ mod node {
let mut node = node;
let mut char_offset = char_offset;
loop {
alt(*node) {
match (*node) {
node::leaf(x) => {
if char_offset == 0u && char_len == x.char_len {
return node;
@ -1007,7 +1007,7 @@ mod node {
}
fn height(node: @node) -> uint {
alt(*node) {
match (*node) {
leaf(_) => return 0u,
concat(x) => return x.height
}
@ -1018,7 +1018,7 @@ mod node {
let itb = char_iterator::start(b);
let mut result = 0;
while result == 0 {
alt((char_iterator::next(ita), char_iterator::next(itb))) {
match ((char_iterator::next(ita), char_iterator::next(itb))) {
(option::none, option::none) => break,
(option::some(chara), option::some(charb)) => {
result = char::cmp(chara, charb);
@ -1059,7 +1059,7 @@ mod node {
fn loop_leaves(node: @node, it: fn(leaf) -> bool) -> bool{
let mut current = node;
loop {
alt(*current) {
match (*current) {
leaf(x) => return it(x),
concat(x) => if loop_leaves(x.left, it) { //non tail call
current = x.right; //tail call
@ -1091,7 +1091,7 @@ mod node {
let mut node = node;
let mut pos = pos;
loop {
alt *node {
match *node {
leaf(x) => return str::char_at(*x.content, pos),
concat({left, right, _}) => {
let left_len = char_len(left);
@ -1126,7 +1126,7 @@ mod node {
loop {
let current = it.stack[it.stackpos];
it.stackpos -= 1;
alt(*current) {
match (*current) {
concat(x) => {
it.stackpos += 1;
it.stack[it.stackpos] = x.right;
@ -1164,11 +1164,11 @@ mod node {
fn next(it: t) -> option<char> {
loop {
alt(get_current_or_next_leaf(it)) {
match (get_current_or_next_leaf(it)) {
option::none => return option::none,
option::some(_) => {
let next_char = get_next_char_in_leaf(it);
alt(next_char) {
match (next_char) {
option::none => again,
option::some(_) => return next_char
}
@ -1178,11 +1178,11 @@ mod node {
}
fn get_current_or_next_leaf(it: t) -> option<leaf> {
alt(it.leaf) {
match (it.leaf) {
option::some(_) => return it.leaf,
option::none => {
let next = leaf_iterator::next(it.leaf_iterator);
alt(next) {
match (next) {
option::none => return option::none,
option::some(_) => {
it.leaf = next;
@ -1195,7 +1195,7 @@ mod node {
}
fn get_next_char_in_leaf(it: t) -> option<char> {
alt copy it.leaf {
match copy it.leaf {
option::none => return option::none,
option::some(aleaf) => {
if it.leaf_byte_pos >= aleaf.byte_len {
@ -1220,12 +1220,12 @@ mod tests {
//Utility function, used for sanity check
fn rope_to_string(r: rope) -> ~str {
alt(r) {
match (r) {
node::empty => return ~"",
node::content(x) => {
let str = @mut ~"";
fn aux(str: @mut ~str, node: @node::node) unsafe {
alt(*node) {
match (*node) {
node::leaf(x) => {
*str += str::slice(
*x.content, x.byte_offset,
@ -1274,7 +1274,7 @@ mod tests {
let rope_iter = iterator::char::start(r);
let mut equal = true;
while equal {
alt(node::char_iterator::next(rope_iter)) {
match (node::char_iterator::next(rope_iter)) {
option::none => {
if string_iter < string_len {
equal = false;
@ -1301,7 +1301,7 @@ mod tests {
let mut len = 0u;
let it = iterator::char::start(r);
loop {
alt(node::char_iterator::next(it)) {
match (node::char_iterator::next(it)) {
option::none => break,
option::some(_) => len += 1u
}

4
src/libstd/serialization.rs
View file

@ -243,7 +243,7 @@ fn deserialize_bool<D: deserializer>(d: D) -> bool {
fn serialize_option<S: serializer,T>(s: S, v: option<T>, st: fn(T)) {
do s.emit_enum(~"option") {
alt v {
match v {
none => do s.emit_enum_variant(~"none", 0u, 0u) {
}
@ -260,7 +260,7 @@ fn deserialize_option<D: deserializer,T: copy>(d: D, st: fn() -> T)
-> option<T> {
do d.read_enum(~"option") {
do d.read_enum_variant |i| {
alt check i {
match check i {
0u => none,
1u => some(d.read_enum_variant_arg(0u, || st() ))
}

8
src/libstd/smallintmap.rs
View file

@ -48,7 +48,7 @@ pure fn find<T: copy>(self: smallintmap<T>, key: uint) -> option<T> {
* If the key does not exist in the map
*/
pure fn get<T: copy>(self: smallintmap<T>, key: uint) -> T {
alt find(self, key) {
match find(self, key) {
none => {
error!{"smallintmap::get(): key not present"};
fail;
@ -67,7 +67,7 @@ impl <V: copy> of map::map<uint, V> for smallintmap<V> {
fn size() -> uint {
let mut sz = 0u;
for self.v.each |item| {
alt item {
match item {
some(_) => sz += 1u,
_ => ()
}
@ -103,7 +103,7 @@ impl <V: copy> of map::map<uint, V> for smallintmap<V> {
fn each(it: fn(+key: uint, +value: V) -> bool) {
let mut idx = 0u, l = self.v.len();
while idx < l {
alt self.v.get_elt(idx) {
match self.v.get_elt(idx) {
some(elt) => if !it(idx, elt) { break }
none => ()
}
@ -119,7 +119,7 @@ impl <V: copy> of map::map<uint, V> for smallintmap<V> {
fn each_ref(it: fn(key: &uint, value: &V) -> bool) {
let mut idx = 0u, l = self.v.len();
while idx < l {
alt self.v.get_elt(idx) {
match self.v.get_elt(idx) {
some(elt) => if !it(&idx, &elt) { break }
none => ()
}

2
src/libstd/tempfile.rs
View file

@ -21,7 +21,7 @@ fn mkdtemp(prefix: ~str, suffix: ~str) -> option<~str> {
#[test]
fn test_mkdtemp() {
let r = mkdtemp(~"./", ~"foobar");
alt r {
match r {
some(p) => {
os::remove_dir(p);
assert(str::ends_with(p, ~"foobar"));

2
src/libstd/term.rs
View file

@ -35,7 +35,7 @@ fn reset(writer: io::writer) {
fn color_supported() -> bool {
let supported_terms = ~[~"xterm-color", ~"xterm",
~"screen-bce", ~"xterm-256color"];
return alt os::getenv(~"TERM") {
return match os::getenv(~"TERM") {
option::some(env) => {
for vec::each(supported_terms) |term| {
if term == env { return true; }

23
src/libstd/test.rs
View file

@ -52,7 +52,7 @@ type test_desc = {
// arguments and a vector of test_descs (generated at compile time).
fn test_main(args: ~[~str], tests: ~[test_desc]) {
let opts =
alt parse_opts(args) {
match parse_opts(args) {
either::left(o) => o,
either::right(m) => fail m
};
@ -69,7 +69,7 @@ fn parse_opts(args: ~[~str]) -> opt_res {
let args_ = vec::tail(args);
let opts = ~[getopts::optflag(~"ignored"), getopts::optopt(~"logfile")];
let matches =
alt getopts::getopts(args_, opts) {
match getopts::getopts(args_, opts) {
ok(m) => m,
err(f) => return either::right(getopts::fail_str(f))
};
@ -105,7 +105,7 @@ fn run_tests_console(opts: test_opts,
tests: ~[test_desc]) -> bool {
fn callback(event: testevent, st: console_test_state) {
alt event {
match event {
te_filtered(filtered_tests) => {
st.total = vec::len(filtered_tests);
let noun = if st.total != 1u { ~"tests" } else { ~"test" };
@ -113,11 +113,11 @@ fn run_tests_console(opts: test_opts,
}
te_wait(test) => st.out.write_str(fmt!{"test %s ... ", test.name}),
te_result(test, result) => {
alt st.log_out {
match st.log_out {
some(f) => write_log(f, result, test),
none => ()
}
alt result {
match result {
tr_ok => {
st.passed += 1u;
write_ok(st.out, st.use_color);
@ -139,8 +139,9 @@ fn run_tests_console(opts: test_opts,
}
}
let log_out = alt opts.logfile {
some(path) => alt io::file_writer(path, ~[io::create, io::truncate]) {
let log_out = match opts.logfile {
some(path) => match io::file_writer(path,
~[io::create, io::truncate]) {
result::ok(w) => some(w),
result::err(s) => {
fail(fmt!{"can't open output file: %s", s})
@ -180,7 +181,7 @@ fn run_tests_console(opts: test_opts,
fn write_log(out: io::writer, result: test_result, test: test_desc) {
out.write_line(fmt!{"%s %s",
alt result {
match result {
tr_ok => ~"ok",
tr_failed => ~"failed",
tr_ignored => ~"ignored"
@ -334,7 +335,7 @@ fn filter_tests(opts: test_opts,
filtered
} else {
let filter_str =
alt opts.filter {
match opts.filter {
option::some(f) => f,
option::none => ~""
};
@ -479,7 +480,7 @@ mod tests {
#[test]
fn first_free_arg_should_be_a_filter() {
let args = ~[~"progname", ~"filter"];
let opts = alt parse_opts(args) {
let opts = match parse_opts(args) {
either::left(o) => o,
_ => fail ~"Malformed arg in first_free_arg_should_be_a_filter"
};
@ -489,7 +490,7 @@ mod tests {
#[test]
fn parse_ignored_flag() {
let args = ~[~"progname", ~"filter", ~"--ignored"];
let opts = alt parse_opts(args) {
let opts = match parse_opts(args) {
either::left(o) => o,
_ => fail ~"Malformed arg in parse_ignored_flag"
};

74
src/libstd/time.rs
View file

@ -181,7 +181,7 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
let {ch, next} = str::char_range_at(s, pos);
pos = next;
alt ch {
match ch {
'0' to '9' => {
value = value * 10_i32 + (ch as i32 - '0' as i32);
}
@ -208,8 +208,8 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
fn parse_type(s: ~str, pos: uint, ch: char, tm: tm_mut)
-> result<uint, ~str> {
alt ch {
'A' => alt match_strs(s, pos, ~[
match ch {
'A' => match match_strs(s, pos, ~[
(~"Sunday", 0_i32),
(~"Monday", 1_i32),
(~"Tuesday", 2_i32),
@ -221,7 +221,7 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
some(item) => { let (v, pos) = item; tm.tm_wday = v; ok(pos) }
none => err(~"Invalid day")
}
'a' => alt match_strs(s, pos, ~[
'a' => match match_strs(s, pos, ~[
(~"Sun", 0_i32),
(~"Mon", 1_i32),
(~"Tue", 2_i32),
@ -233,7 +233,7 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
some(item) => { let (v, pos) = item; tm.tm_wday = v; ok(pos) }
none => err(~"Invalid day")
}
'B' => alt match_strs(s, pos, ~[
'B' => match match_strs(s, pos, ~[
(~"January", 0_i32),
(~"February", 1_i32),
(~"March", 2_i32),
@ -250,7 +250,7 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
some(item) => { let (v, pos) = item; tm.tm_mon = v; ok(pos) }
none => err(~"Invalid month")
}
'b' | 'h' => alt match_strs(s, pos, ~[
'b' | 'h' => match match_strs(s, pos, ~[
(~"Jan", 0_i32),
(~"Feb", 1_i32),
(~"Mar", 2_i32),
@ -267,7 +267,7 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
some(item) => { let (v, pos) = item; tm.tm_mon = v; ok(pos) }
none => err(~"Invalid month")
}
'C' => alt match_digits(s, pos, 2u, false) {
'C' => match match_digits(s, pos, 2u, false) {
some(item) => {
let (v, pos) = item;
tm.tm_year += (v * 100_i32) - 1900_i32;
@ -293,11 +293,11 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
.chain(|pos| parse_char(s, pos, '/'))
.chain(|pos| parse_type(s, pos, 'y', tm))
}
'd' => alt match_digits(s, pos, 2u, false) {
'd' => match match_digits(s, pos, 2u, false) {
some(item) => { let (v, pos) = item; tm.tm_mday = v; ok(pos) }
none => err(~"Invalid day of the month")
}
'e' => alt match_digits(s, pos, 2u, true) {
'e' => match match_digits(s, pos, 2u, true) {
some(item) => { let (v, pos) = item; tm.tm_mday = v; ok(pos) }
none => err(~"Invalid day of the month")
}
@ -310,14 +310,14 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
}
'H' => {
// FIXME (#2350): range check.
alt match_digits(s, pos, 2u, false) {
match match_digits(s, pos, 2u, false) {
some(item) => { let (v, pos) = item; tm.tm_hour = v; ok(pos) }
none => err(~"Invalid hour")
}
}
'I' => {
// FIXME (#2350): range check.
alt match_digits(s, pos, 2u, false) {
match match_digits(s, pos, 2u, false) {
some(item) => {
let (v, pos) = item;
tm.tm_hour = if v == 12_i32 { 0_i32 } else { v };
@ -328,7 +328,7 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
}
'j' => {
// FIXME (#2350): range check.
alt match_digits(s, pos, 3u, false) {
match match_digits(s, pos, 3u, false) {
some(item) => {
let (v, pos) = item;
tm.tm_yday = v - 1_i32;
@ -339,14 +339,14 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
}
'k' => {
// FIXME (#2350): range check.
alt match_digits(s, pos, 2u, true) {
match match_digits(s, pos, 2u, true) {
some(item) => { let (v, pos) = item; tm.tm_hour = v; ok(pos) }
none => err(~"Invalid hour")
}
}
'l' => {
// FIXME (#2350): range check.
alt match_digits(s, pos, 2u, true) {
match match_digits(s, pos, 2u, true) {
some(item) => {
let (v, pos) = item;
tm.tm_hour = if v == 12_i32 { 0_i32 } else { v };
@ -357,14 +357,14 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
}
'M' => {
// FIXME (#2350): range check.
alt match_digits(s, pos, 2u, false) {
match match_digits(s, pos, 2u, false) {
some(item) => { let (v, pos) = item; tm.tm_min = v; ok(pos) }
none => err(~"Invalid minute")
}
}
'm' => {
// FIXME (#2350): range check.
alt match_digits(s, pos, 2u, false) {
match match_digits(s, pos, 2u, false) {
some(item) => {
let (v, pos) = item;
tm.tm_mon = v - 1_i32;
@ -374,11 +374,15 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
}
}
'n' => parse_char(s, pos, '\n'),
'P' => alt match_strs(s, pos, ~[(~"am", 0_i32), (~"pm", 12_i32)]) {
'P' => match match_strs(s, pos,
~[(~"am", 0_i32), (~"pm", 12_i32)]) {
some(item) => { let (v, pos) = item; tm.tm_hour += v; ok(pos) }
none => err(~"Invalid hour")
}
'p' => alt match_strs(s, pos, ~[(~"AM", 0_i32), (~"PM", 12_i32)]) {
'p' => match match_strs(s, pos,
~[(~"AM", 0_i32), (~"PM", 12_i32)]) {
some(item) => { let (v, pos) = item; tm.tm_hour += v; ok(pos) }
none => err(~"Invalid hour")
}
@ -398,7 +402,7 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
}
'S' => {
// FIXME (#2350): range check.
alt match_digits(s, pos, 2u, false) {
match match_digits(s, pos, 2u, false) {
some(item) => {
let (v, pos) = item;
tm.tm_sec = v;
@ -418,7 +422,7 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
't' => parse_char(s, pos, '\t'),
'u' => {
// FIXME (#2350): range check.
alt match_digits(s, pos, 1u, false) {
match match_digits(s, pos, 1u, false) {
some(item) => {
let (v, pos) = item;
tm.tm_wday = v;
@ -437,7 +441,7 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
//'W' {}
'w' => {
// FIXME (#2350): range check.
alt match_digits(s, pos, 1u, false) {
match match_digits(s, pos, 1u, false) {
some(item) => { let (v, pos) = item; tm.tm_wday = v; ok(pos) }
none => err(~"Invalid weekday")
}
@ -446,7 +450,7 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
//'x' {}
'Y' => {
// FIXME (#2350): range check.
alt match_digits(s, pos, 4u, false) {
match match_digits(s, pos, 4u, false) {
some(item) => {
let (v, pos) = item;
tm.tm_year = v - 1900_i32;
@ -457,7 +461,7 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
}
'y' => {
// FIXME (#2350): range check.
alt match_digits(s, pos, 2u, false) {
match match_digits(s, pos, 2u, false) {
some(item) => {
let (v, pos) = item;
tm.tm_year = v - 1900_i32;
@ -489,7 +493,7 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
let {ch, next} = str::char_range_at(s, pos);
if ch == '+' || ch == '-' {
alt match_digits(s, next, 4u, false) {
match match_digits(s, next, 4u, false) {
some(item) => {
let (v, pos) = item;
if v == 0_i32 {
@ -534,8 +538,8 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
while !rdr.eof() && pos < len {
let {ch, next} = str::char_range_at(s, pos);
alt rdr.read_char() {
'%' => alt parse_type(s, pos, rdr.read_char(), tm) {
match rdr.read_char() {
'%' => match parse_type(s, pos, rdr.read_char(), tm) {
ok(next) => pos = next,
err(e) => { result = err(e); break; }
}
@ -568,8 +572,8 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
fn strftime(format: ~str, tm: tm) -> ~str {
fn parse_type(ch: char, tm: tm) -> ~str {
//FIXME (#2350): Implement missing types.
alt check ch {
'A' => alt check tm.tm_wday as int {
match check ch {
'A' => match check tm.tm_wday as int {
0 => ~"Sunday",
1 => ~"Monday",
2 => ~"Tuesday",
@ -578,7 +582,7 @@ fn strftime(format: ~str, tm: tm) -> ~str {
5 => ~"Friday",
6 => ~"Saturday"
}
'a' => alt check tm.tm_wday as int {
'a' => match check tm.tm_wday as int {
0 => ~"Sun",
1 => ~"Mon",
2 => ~"Tue",
@ -587,7 +591,7 @@ fn strftime(format: ~str, tm: tm) -> ~str {
5 => ~"Fri",
6 => ~"Sat"
}
'B' => alt check tm.tm_mon as int {
'B' => match check tm.tm_mon as int {
0 => ~"January",
1 => ~"February",
2 => ~"March",
@ -601,7 +605,7 @@ fn strftime(format: ~str, tm: tm) -> ~str {
10 => ~"November",
11 => ~"December"
}
'b' | 'h' => alt check tm.tm_mon as int {
'b' | 'h' => match check tm.tm_mon as int {
0 => ~"Jan",
1 => ~"Feb",
2 => ~"Mar",
@ -716,7 +720,7 @@ fn strftime(format: ~str, tm: tm) -> ~str {
do io::with_str_reader(format) |rdr| {
while !rdr.eof() {
alt rdr.read_char() {
match rdr.read_char() {
'%' => buf += parse_type(rdr.read_char(), tm),
ch => str::push_char(buf, ch)
}
@ -932,7 +936,7 @@ mod tests {
os::setenv(~"TZ", ~"America/Los_Angeles");
tzset();
alt strptime(~"", ~"") {
match strptime(~"", ~"") {
ok(tm) => {
assert tm.tm_sec == 0_i32;
assert tm.tm_min == 0_i32;
@ -954,7 +958,7 @@ mod tests {
assert strptime(~"Fri Feb 13 15:31:30", format)
== err(~"Invalid time");
alt strptime(~"Fri Feb 13 15:31:30 2009", format) {
match strptime(~"Fri Feb 13 15:31:30 2009", format) {
err(e) => fail e,
ok(tm) => {
assert tm.tm_sec == 30_i32;
@ -973,7 +977,7 @@ mod tests {
}
fn test(s: ~str, format: ~str) -> bool {
alt strptime(s, format) {
match strptime(s, format) {
ok(tm) => tm.strftime(format) == s,
err(e) => fail e
}

4
src/libstd/timer.rs
View file

@ -215,7 +215,7 @@ mod test {
delayed_send(hl_loop, 1u, test_ch, expected);
};
alt recv_timeout(hl_loop, 10u, test_po) {
match recv_timeout(hl_loop, 10u, test_po) {
some(val) => {
assert val == expected;
successes += 1;
@ -243,7 +243,7 @@ mod test {
delayed_send(hl_loop, 1000u, test_ch, expected);
};
alt recv_timeout(hl_loop, 1u, test_po) {
match recv_timeout(hl_loop, 1u, test_po) {
none => successes += 1,
_ => failures += 1
};

6
src/libstd/treemap.rs
View file

@ -30,7 +30,7 @@ fn treemap<K, V>() -> treemap<K, V> { @mut none }
/// Insert a value into the map
fn insert<K: copy, V: copy>(m: &mut tree_edge<K, V>, k: K, v: V) {
alt copy *m {
match copy *m {
none => {
*m = some(@tree_node({key: k,
mut value: v,
@ -52,7 +52,7 @@ fn insert<K: copy, V: copy>(m: &mut tree_edge<K, V>, k: K, v: V) {
/// Find a value based on the key
fn find<K: copy, V: copy>(m: &const tree_edge<K, V>, k: K) -> option<V> {
alt copy *m {
match copy *m {
none => none,
// FIXME (#2808): was that an optimization?
@ -70,7 +70,7 @@ fn find<K: copy, V: copy>(m: &const tree_edge<K, V>, k: K) -> option<V> {
/// Visit all pairs in the map in order.
fn traverse<K, V: copy>(m: &const tree_edge<K, V>, f: fn(K, V)) {
alt copy *m {
match copy *m {
none => (),
some(node) => {
traverse(&const node.left, f);

2
src/libstd/uv_global_loop.rs
View file

@ -56,7 +56,7 @@ fn get_monitor_task_gl() -> iotask unsafe {
let hl_loop = spawn_loop();
loop {
debug!{"in outer_loop..."};
alt select2(weak_exit_po, msg_po) {
match select2(weak_exit_po, msg_po) {
left(weak_exit) => {
// all normal tasks have ended, tell the
// libuv loop to tear_down, then exit

2
src/libstd/uv_iotask.rs
View file

@ -144,7 +144,7 @@ extern fn wake_up_cb(async_handle: *ll::uv_async_t,
let msg_po = (*data).msg_po;
while msg_po.peek() {
alt msg_po.recv() {
match msg_po.recv() {
interaction(cb) => cb(loop_ptr),
teardown_loop => begin_teardown(data)
}

2
src/libstd/uv_ll.rs
View file

@ -848,7 +848,7 @@ unsafe fn ip6_name(src: &sockaddr_in6) -> ~str {
src_unsafe_ptr, src});
let result = rustrt::rust_uv_ip6_name(src_unsafe_ptr,
dst_buf, size as libc::size_t);
alt result {
match result {
0i32 => str::unsafe::from_buf(dst_buf),
_ => ~""
}

2
src/libsyntax/ast.rs
View file

@ -193,7 +193,7 @@ enum vstore {
}
pure fn is_blockish(p: ast::proto) -> bool {
alt p {
match p {
proto_block => true,
proto_bare | proto_uniq | proto_box => false
}

20
src/libsyntax/ast_map.rs
View file

@ -12,7 +12,7 @@ type path = ~[path_elt];
/* FIXMEs that say "bad" are as per #2543 */
fn path_to_str_with_sep(p: path, sep: ~str) -> ~str {
let strs = do vec::map(p) |e| {
alt e {
match e {
path_mod(s) => /* FIXME (#2543) */ copy *s,
path_name(s) => /* FIXME (#2543) */ copy *s
}
@ -104,7 +104,7 @@ fn map_decoded_item(diag: span_handler,
// methods get added to the AST map when their impl is visited. Since we
// don't decode and instantiate the impl, but just the method, we have to
// add it to the table now:
alt ii {
match ii {
ii_item(*) | ii_ctor(*) | ii_dtor(*) => { /* fallthrough */ }
ii_foreign(i) => {
cx.map.insert(i.id, node_foreign_item(i, foreign_abi_rust_intrinsic,
@ -127,7 +127,7 @@ fn map_fn(fk: visit::fn_kind, decl: fn_decl, body: blk,
copy a, cx.local_id));
cx.local_id += 1u;
}
alt fk {
match fk {
visit::fk_ctor(nm, attrs, tps, self_id, parent_id) => {
let ct = @{node: {id: id,
attrs: attrs,
@ -159,7 +159,7 @@ fn map_block(b: blk, cx: ctx, v: vt) {
fn number_pat(cx: ctx, pat: @pat) {
do ast_util::walk_pat(pat) |p| {
alt p.node {
match p.node {
pat_ident(*) => {
cx.map.insert(p.id, node_local(cx.local_id));
cx.local_id += 1u;
@ -189,7 +189,7 @@ fn map_method(impl_did: def_id, impl_path: @path,
fn map_item(i: @item, cx: ctx, v: vt) {
let item_path = @/* FIXME (#2543) */ copy cx.path;
cx.map.insert(i.id, node_item(i, item_path));
alt i.node {
match i.node {
item_impl(_, opt_ir, _, ms) => {
let impl_did = ast_util::local_def(i.id);
for ms.each |m| {
@ -205,7 +205,7 @@ fn map_item(i: @item, cx: ctx, v: vt) {
}
}
item_foreign_mod(nm) => {
let abi = alt attr::foreign_abi(i.attrs) {
let abi = match attr::foreign_abi(i.attrs) {
either::left(msg) => cx.diag.span_fatal(i.span, msg),
either::right(abi) => abi
};
@ -248,7 +248,7 @@ fn map_item(i: @item, cx: ctx, v: vt) {
}
_ => ()
}
alt i.node {
match i.node {
item_mod(_) | item_foreign_mod(_) => {
vec::push(cx.path, path_mod(i.ident));
}
@ -259,9 +259,9 @@ fn map_item(i: @item, cx: ctx, v: vt) {
}
fn map_view_item(vi: @view_item, cx: ctx, _v: vt) {
alt vi.node {
match vi.node {
view_item_export(vps) => for vps.each |vp| {
let (id, name) = alt vp.node {
let (id, name) = match vp.node {
view_path_simple(nm, _, id) => {
(id, /* FIXME (#2543) */ copy nm)
}
@ -281,7 +281,7 @@ fn map_expr(ex: @expr, cx: ctx, v: vt) {
}
fn node_id_to_str(map: map, id: node_id) -> ~str {
alt map.find(id) {
match map.find(id) {
none => {
fmt!{"unknown node (id=%d)", id}
}

80
src/libsyntax/ast_util.rs
View file

@ -35,7 +35,7 @@ pure fn local_def(id: node_id) -> def_id { {crate: local_crate, node: id} }
pure fn is_local(did: ast::def_id) -> bool { did.crate == local_crate }
pure fn stmt_id(s: stmt) -> node_id {
alt s.node {
match s.node {
stmt_decl(_, id) => id,
stmt_expr(_, id) => id,
stmt_semi(_, id) => id
@ -43,7 +43,7 @@ pure fn stmt_id(s: stmt) -> node_id {
}
fn variant_def_ids(d: def) -> {enm: def_id, var: def_id} {
alt d {
match d {
def_variant(enum_id, var_id) => {
return {enm: enum_id, var: var_id}
}
@ -52,7 +52,7 @@ fn variant_def_ids(d: def) -> {enm: def_id, var: def_id} {
}
pure fn def_id_of_def(d: def) -> def_id {
alt d {
match d {
def_fn(id, _) | def_mod(id) |
def_foreign_mod(id) | def_const(id) |
def_variant(_, id) | def_ty(id) | def_ty_param(id, _) |
@ -70,7 +70,7 @@ pure fn def_id_of_def(d: def) -> def_id {
}
pure fn binop_to_str(op: binop) -> ~str {
alt op {
match op {
add => return ~"+",
subtract => return ~"-",
mul => return ~"*",
@ -93,7 +93,7 @@ pure fn binop_to_str(op: binop) -> ~str {
}
pure fn binop_to_method_name(op: binop) -> option<~str> {
alt op {
match op {
add => return some(~"add"),
subtract => return some(~"sub"),
mul => return some(~"mul"),
@ -109,7 +109,7 @@ pure fn binop_to_method_name(op: binop) -> option<~str> {
}
pure fn lazy_binop(b: binop) -> bool {
alt b {
match b {
and => true,
or => true,
_ => false
@ -117,7 +117,7 @@ pure fn lazy_binop(b: binop) -> bool {
}
pure fn is_shift_binop(b: binop) -> bool {
alt b {
match b {
shl => true,
shr => true,
_ => false
@ -125,7 +125,7 @@ pure fn is_shift_binop(b: binop) -> bool {
}
pure fn unop_to_str(op: unop) -> ~str {
alt op {
match op {
box(mt) => if mt == m_mutbl { ~"@mut " } else { ~"@" },
uniq(mt) => if mt == m_mutbl { ~"~mut " } else { ~"~" },
deref => ~"*",
@ -135,11 +135,11 @@ pure fn unop_to_str(op: unop) -> ~str {
}
pure fn is_path(e: @expr) -> bool {
return alt e.node { expr_path(_) => true, _ => false };
return match e.node { expr_path(_) => true, _ => false };
}
pure fn int_ty_to_str(t: int_ty) -> ~str {
alt t {
match t {
ty_char => ~"u8", // ???
ty_i => ~"",
ty_i8 => ~"i8",
@ -150,7 +150,7 @@ pure fn int_ty_to_str(t: int_ty) -> ~str {
}
pure fn int_ty_max(t: int_ty) -> u64 {
alt t {
match t {
ty_i8 => 0x80u64,
ty_i16 => 0x8000u64,
ty_i | ty_char | ty_i32 => 0x80000000u64, // actually ni about ty_i
@ -159,7 +159,7 @@ pure fn int_ty_max(t: int_ty) -> u64 {
}
pure fn uint_ty_to_str(t: uint_ty) -> ~str {
alt t {
match t {
ty_u => ~"u",
ty_u8 => ~"u8",
ty_u16 => ~"u16",
@ -169,7 +169,7 @@ pure fn uint_ty_to_str(t: uint_ty) -> ~str {
}
pure fn uint_ty_max(t: uint_ty) -> u64 {
alt t {
match t {
ty_u8 => 0xffu64,
ty_u16 => 0xffffu64,
ty_u | ty_u32 => 0xffffffffu64, // actually ni about ty_u
@ -178,7 +178,7 @@ pure fn uint_ty_max(t: uint_ty) -> u64 {
}
pure fn float_ty_to_str(t: float_ty) -> ~str {
alt t { ty_f => ~"f", ty_f32 => ~"f32", ty_f64 => ~"f64" }
match t { ty_f => ~"f", ty_f32 => ~"f32", ty_f64 => ~"f64" }
}
fn is_exported(i: ident, m: _mod) -> bool {
@ -186,7 +186,7 @@ fn is_exported(i: ident, m: _mod) -> bool {
let mut parent_enum : option<ident> = none;
for m.items.each |it| {
if it.ident == i { local = true; }
alt it.node {
match it.node {
item_enum(variants, _) => for variants.each |v| {
if v.node.name == i {
local = true;
@ -199,14 +199,14 @@ fn is_exported(i: ident, m: _mod) -> bool {
}
let mut has_explicit_exports = false;
for m.view_items.each |vi| {
alt vi.node {
match vi.node {
view_item_export(vps) => {
has_explicit_exports = true;
for vps.each |vp| {
alt vp.node {
match vp.node {
ast::view_path_simple(id, _, _) => {
if id == i { return true; }
alt parent_enum {
match parent_enum {
some(parent_enum_id) => {
if id == parent_enum_id { return true; }
}
@ -240,7 +240,7 @@ fn is_exported(i: ident, m: _mod) -> bool {
}
pure fn is_call_expr(e: @expr) -> bool {
alt e.node { expr_call(_, _, _) => true, _ => false }
match e.node { expr_call(_, _, _) => true, _ => false }
}
pure fn eq_ty(a: &@ty, b: &@ty) -> bool { box::ptr_eq(*a, *b) }
@ -284,7 +284,7 @@ fn ident_to_path(s: span, +i: ident) -> @path {
}
pure fn is_unguarded(&&a: arm) -> bool {
alt a.guard {
match a.guard {
none => true,
_ => false
}
@ -295,7 +295,7 @@ pure fn unguarded_pat(a: arm) -> option<~[@pat]> {
}
pure fn class_item_ident(ci: @class_member) -> ident {
alt ci.node {
match ci.node {
instance_var(i,_,_,_,_) => /* FIXME (#2543) */ copy i,
class_method(it) => /* FIXME (#2543) */ copy it.ident
}
@ -306,7 +306,7 @@ type ivar = {ident: ident, ty: @ty, cm: class_mutability,
fn public_methods(ms: ~[@method]) -> ~[@method] {
vec::filter(ms,
|m| alt m.vis {
|m| match m.vis {
public => true,
_ => false
})
@ -315,7 +315,7 @@ fn public_methods(ms: ~[@method]) -> ~[@method] {
fn split_class_items(cs: ~[@class_member]) -> (~[ivar], ~[@method]) {
let mut vs = ~[], ms = ~[];
for cs.each |c| {
alt c.node {
match c.node {
instance_var(i, t, cm, id, vis) => {
vec::push(vs, {ident: /* FIXME (#2543) */ copy i,
ty: t,
@ -332,7 +332,7 @@ fn split_class_items(cs: ~[@class_member]) -> (~[ivar], ~[@method]) {
// extract a ty_method from a trait_method. if the trait_method is
// a default, pull out the useful fields to make a ty_method
fn trait_method_to_ty_method(method: trait_method) -> ty_method {
alt method {
match method {
required(m) => m,
provided(m) => {
{ident: m.ident, attrs: m.attrs,
@ -346,7 +346,7 @@ fn split_trait_methods(trait_methods: ~[trait_method])
-> (~[ty_method], ~[@method]) {
let mut reqd = ~[], provd = ~[];
for trait_methods.each |trt_method| {
alt trt_method {
match trt_method {
required(tm) => vec::push(reqd, tm),
provided(m) => vec::push(provd, m)
}
@ -355,7 +355,7 @@ fn split_trait_methods(trait_methods: ~[trait_method])
}
pure fn class_member_visibility(ci: @class_member) -> visibility {
alt ci.node {
match ci.node {
instance_var(_, _, _, _, vis) => vis,
class_method(m) => m.vis
}
@ -369,7 +369,7 @@ trait inlined_item_utils {
impl inlined_item_methods of inlined_item_utils for inlined_item {
fn ident() -> ident {
alt self {
match self {
ii_item(i) => /* FIXME (#2543) */ copy i.ident,
ii_foreign(i) => /* FIXME (#2543) */ copy i.ident,
ii_method(_, m) => /* FIXME (#2543) */ copy m.ident,
@ -379,7 +379,7 @@ impl inlined_item_methods of inlined_item_utils for inlined_item {
}
fn id() -> ast::node_id {
alt self {
match self {
ii_item(i) => i.id,
ii_foreign(i) => i.id,
ii_method(_, m) => m.id,
@ -389,7 +389,7 @@ impl inlined_item_methods of inlined_item_utils for inlined_item {
}
fn accept<E>(e: E, v: visit::vt<E>) {
alt self {
match self {
ii_item(i) => v.visit_item(i, e, v),
ii_foreign(i) => v.visit_foreign_item(i, e, v),
ii_method(_, m) => visit::visit_method_helper(m, e, v),
@ -406,7 +406,7 @@ impl inlined_item_methods of inlined_item_utils for inlined_item {
/* True if d is either a def_self, or a chain of def_upvars
referring to a def_self */
fn is_self(d: ast::def) -> bool {
alt d {
match d {
def_self(_) => true,
def_upvar(_, d, _) => is_self(*d),
_ => false
@ -415,7 +415,7 @@ fn is_self(d: ast::def) -> bool {
/// Maps a binary operator to its precedence
fn operator_prec(op: ast::binop) -> uint {
alt op {
match op {
mul | div | rem => 12u,
// 'as' sits between here with 11
add | subtract => 10u,
@ -455,11 +455,11 @@ fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> {
},
visit_view_item: fn@(vi: @view_item) {
alt vi.node {
match vi.node {
view_item_use(_, _, id) => vfn(id),
view_item_import(vps) | view_item_export(vps) => {
do vec::iter(vps) |vp| {
alt vp.node {
match vp.node {
view_path_simple(_, _, id) => vfn(id),
view_path_glob(_, id) => vfn(id),
view_path_list(_, _, id) => vfn(id)
@ -475,7 +475,7 @@ fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> {
visit_item: fn@(i: @item) {
vfn(i.id);
alt i.node {
match i.node {
item_enum(vs, _) => for vs.each |v| { vfn(v.node.id); }
_ => ()
}
@ -511,7 +511,7 @@ fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> {
},
visit_ty: fn@(t: @ty) {
alt t.node {
match t.node {
ty_path(_, id) => vfn(id),
_ => { /* fall through */ }
}
@ -525,7 +525,7 @@ fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> {
_b: ast::blk, _sp: span, id: ast::node_id) {
vfn(id);
alt fk {
match fk {
visit::fk_ctor(nm, _, tps, self_id, parent_id) => {
vec::iter(tps, |tp| vfn(tp.id));
vfn(id);
@ -565,7 +565,7 @@ fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> {
},
visit_class_item: fn@(c: @class_member) {
alt c.node {
match c.node {
instance_var(_, _, _, id,_) => vfn(id),
class_method(_) => ()
}
@ -592,7 +592,7 @@ fn compute_id_range_for_inlined_item(item: inlined_item) -> id_range {
}
pure fn is_item_impl(item: @ast::item) -> bool {
alt item.node {
match item.node {
item_impl(*) => true,
_ => false
}
@ -600,7 +600,7 @@ pure fn is_item_impl(item: @ast::item) -> bool {
fn walk_pat(pat: @pat, it: fn(@pat)) {
it(pat);
alt pat.node {
match pat.node {
pat_ident(_, pth, some(p)) => walk_pat(p, it),
pat_rec(fields, _) => for fields.each |f| { walk_pat(f.pat, it) }
pat_enum(_, some(s)) | pat_tup(s) => for s.each |p| {
@ -613,7 +613,7 @@ fn walk_pat(pat: @pat, it: fn(@pat)) {
}
fn view_path_id(p: @view_path) -> node_id {
alt p.node {
match p.node {
view_path_simple(_, _, id) | view_path_glob(_, id) |
view_path_list(_, _, id) => id
}

32
src/libsyntax/attr.rs
View file

@ -114,7 +114,7 @@ fn get_attr_name(attr: ast::attribute) -> ast::ident {
// All "bad" FIXME copies are as per #2543
fn get_meta_item_name(meta: @ast::meta_item) -> ast::ident {
alt meta.node {
match meta.node {
ast::meta_word(n) => /* FIXME (#2543) */ copy n,
ast::meta_name_value(n, _) => /* FIXME (#2543) */ copy n,
ast::meta_list(n, _) => /* FIXME (#2543) */ copy n
@ -126,8 +126,8 @@ fn get_meta_item_name(meta: @ast::meta_item) -> ast::ident {
* containing a string, otherwise none
*/
fn get_meta_item_value_str(meta: @ast::meta_item) -> option<@~str> {
alt meta.node {
ast::meta_name_value(_, v) => alt v.node {
match meta.node {
ast::meta_name_value(_, v) => match v.node {
ast::lit_str(s) => option::some(s),
_ => option::none
}
@ -137,7 +137,7 @@ fn get_meta_item_value_str(meta: @ast::meta_item) -> option<@~str> {
/// Gets a list of inner meta items from a list meta_item type
fn get_meta_item_list(meta: @ast::meta_item) -> option<~[@ast::meta_item]> {
alt meta.node {
match meta.node {
ast::meta_list(_, l) => option::some(/* FIXME (#2543) */ copy l),
_ => option::none
}
@ -150,7 +150,7 @@ fn get_meta_item_list(meta: @ast::meta_item) -> option<~[@ast::meta_item]> {
fn get_name_value_str_pair(
item: @ast::meta_item
) -> option<(ast::ident, @~str)> {
alt attr::get_meta_item_value_str(item) {
match attr::get_meta_item_value_str(item) {
some(value) => {
let name = attr::get_meta_item_name(item);
some((name, value))
@ -203,12 +203,12 @@ fn contains(haystack: ~[@ast::meta_item], needle: @ast::meta_item) -> bool {
}
fn eq(a: @ast::meta_item, b: @ast::meta_item) -> bool {
return alt a.node {
ast::meta_word(na) => alt b.node {
return match a.node {
ast::meta_word(na) => match b.node {
ast::meta_word(nb) => na == nb,
_ => false
}
ast::meta_name_value(na, va) => alt b.node {
ast::meta_name_value(na, va) => match b.node {
ast::meta_name_value(nb, vb) => na == nb && va.node == vb.node,
_ => false
}
@ -253,8 +253,8 @@ fn last_meta_item_value_str_by_name(
items: ~[@ast::meta_item],
+name: ~str
) -> option<@~str> {
alt last_meta_item_by_name(items, name) {
some(item) => alt attr::get_meta_item_value_str(item) {
match last_meta_item_by_name(items, name) {
some(item) => match attr::get_meta_item_value_str(item) {
some(value) => some(value),
none => none
}
@ -266,7 +266,7 @@ fn last_meta_item_list_by_name(
items: ~[@ast::meta_item],
+name: ~str
) -> option<~[@ast::meta_item]> {
alt last_meta_item_by_name(items, name) {
match last_meta_item_by_name(items, name) {
some(item) => attr::get_meta_item_list(item),
none => none
}
@ -280,7 +280,7 @@ fn last_meta_item_list_by_name(
fn sort_meta_items(+items: ~[@ast::meta_item]) -> ~[@ast::meta_item] {
pure fn lteq(ma: &@ast::meta_item, mb: &@ast::meta_item) -> bool {
pure fn key(m: &ast::meta_item) -> ast::ident {
alt m.node {
match m.node {
ast::meta_word(name) => /* FIXME (#2543) */ copy name,
ast::meta_name_value(name, _) => /* FIXME (#2543) */ copy name,
ast::meta_list(name, _) => /* FIXME (#2543) */ copy name
@ -310,7 +310,7 @@ fn remove_meta_items_by_name(items: ~[@ast::meta_item], name: ast::ident) ->
fn find_linkage_attrs(attrs: ~[ast::attribute]) -> ~[ast::attribute] {
let mut found = ~[];
for find_attrs_by_name(attrs, ~"link").each |attr| {
alt attr.node.value.node {
match attr.node.value.node {
ast::meta_list(_, _) => vec::push(found, attr),
_ => debug!{"ignoring link attribute that has incorrect type"}
}
@ -324,14 +324,14 @@ fn find_linkage_attrs(attrs: ~[ast::attribute]) -> ~[ast::attribute] {
*/
fn find_linkage_metas(attrs: ~[ast::attribute]) -> ~[@ast::meta_item] {
do find_linkage_attrs(attrs).flat_map |attr| {
alt check attr.node.value.node {
match check attr.node.value.node {
ast::meta_list(_, items) => /* FIXME (#2543) */ copy items
}
}
}
fn foreign_abi(attrs: ~[ast::attribute]) -> either<~str, ast::foreign_abi> {
return alt attr::first_attr_value_str_by_name(attrs, ~"abi") {
return match attr::first_attr_value_str_by_name(attrs, ~"abi") {
option::none => {
either::right(ast::foreign_abi_cdecl)
}
@ -361,7 +361,7 @@ enum inline_attr {
fn find_inline_attr(attrs: ~[ast::attribute]) -> inline_attr {
// FIXME (#2809)---validate the usage of #[inline] and #[inline(always)]
do vec::foldl(ia_none, attrs) |ia,attr| {
alt attr.node.value.node {
match attr.node.value.node {
ast::meta_word(@~"inline") => ia_hint,
ast::meta_list(@~"inline", items) => {
if !vec::is_empty(find_meta_items_by_name(items, ~"always")) {

6
src/libsyntax/codemap.rs
View file

@ -124,7 +124,7 @@ fn lookup_char_pos_adj(map: codemap, pos: uint)
-> {filename: ~str, line: uint, col: uint, file: option<filemap>}
{
let loc = lookup_char_pos(map, pos);
alt (loc.file.substr) {
match (loc.file.substr) {
fss_none => {
{filename: /* FIXME (#2543) */ copy loc.file.name,
line: loc.line,
@ -146,7 +146,7 @@ fn lookup_char_pos_adj(map: codemap, pos: uint)
fn adjust_span(map: codemap, sp: span) -> span {
pure fn lookup(pos: file_pos) -> uint { return pos.ch; }
let line = lookup_line(map, sp.lo, lookup);
alt (line.fm.substr) {
match (line.fm.substr) {
fss_none => sp,
fss_internal(s) => {
adjust_span(map, {lo: s.lo + (sp.lo - line.fm.start_pos.ch),
@ -196,7 +196,7 @@ fn span_to_lines(sp: span, cm: codemap::codemap) -> @file_lines {
fn get_line(fm: filemap, line: int) -> ~str unsafe {
let begin: uint = fm.lines[line].byte - fm.start_pos.byte;
let end = alt str::find_char_from(*fm.src, '\n', begin) {
let end = match str::find_char_from(*fm.src, '\n', begin) {
some(e) => e,
none => str::len(*fm.src)
};

12
src/libsyntax/diagnostic.rs
View file

@ -87,7 +87,7 @@ impl codemap_handler of handler for handler_t {
fn has_errors() -> bool { self.err_count > 0u }
fn abort_if_errors() {
let s;
alt self.err_count {
match self.err_count {
0u => return,
1u => s = ~"aborting due to previous error",
_ => {
@ -122,7 +122,7 @@ fn mk_span_handler(handler: handler, cm: codemap::codemap) -> span_handler {
fn mk_handler(emitter: option<emitter>) -> handler {
let emit = alt emitter {
let emit = match emitter {
some(e) => e,
none => {
let f = fn@(cmsp: option<(codemap::codemap, span)>,
@ -147,7 +147,7 @@ enum level {
}
fn diagnosticstr(lvl: level) -> ~str {
alt lvl {
match lvl {
fatal => ~"error",
error => ~"error",
warning => ~"warning",
@ -156,7 +156,7 @@ fn diagnosticstr(lvl: level) -> ~str {
}
fn diagnosticcolor(lvl: level) -> u8 {
alt lvl {
match lvl {
fatal => term::color_bright_red,
error => term::color_bright_red,
warning => term::color_bright_yellow,
@ -182,7 +182,7 @@ fn print_diagnostic(topic: ~str, lvl: level, msg: ~str) {
fn emit(cmsp: option<(codemap::codemap, span)>,
msg: ~str, lvl: level) {
alt cmsp {
match cmsp {
some((cm, sp)) => {
let sp = codemap::adjust_span(cm,sp);
let ss = codemap::span_to_str(sp, cm);
@ -266,7 +266,7 @@ fn print_macro_backtrace(cm: codemap::codemap, sp: span) {
fn expect<T: copy>(diag: span_handler,
opt: option<T>, msg: fn() -> ~str) -> T {
alt opt {
match opt {
some(t) => t,
none => diag.handler().bug(msg())
}

14
src/libsyntax/ext/auto_serialize.rs
View file

@ -101,7 +101,7 @@ fn expand(cx: ext_ctxt,
}
do vec::flat_map(in_items) |in_item| {
alt in_item.node {
match in_item.node {
ast::item_ty(ty, tps) => {
vec::append(~[filter_attrs(in_item)],
ty_fns(cx, in_item.ident, ty, tps))
@ -375,7 +375,7 @@ fn ser_lambda(cx: ext_ctxt, tps: ser_tps_map, ty: @ast::ty,
}
fn is_vec_or_str(ty: @ast::ty) -> bool {
alt ty.node {
match ty.node {
ast::ty_vec(_) => true,
// This may be wrong if the user has shadowed (!) str
ast::ty_path(@{span: _, global: _, idents: ids,
@ -391,7 +391,7 @@ fn ser_ty(cx: ext_ctxt, tps: ser_tps_map,
let ext_cx = cx; // required for #ast{}
alt ty.node {
match ty.node {
ast::ty_nil => {
~[#ast[stmt]{$(s).emit_nil()}]
}
@ -447,7 +447,7 @@ fn ser_ty(cx: ext_ctxt, tps: ser_tps_map,
ast::ty_tup(tys) => {
// Generate code like
//
// alt v {
// match v {
// (v1, v2, v3) {
// .. serialize v1, v2, v3 ..
// }
@ -483,7 +483,7 @@ fn ser_ty(cx: ext_ctxt, tps: ser_tps_map,
vec::is_empty(path.types) {
let ident = path.idents[0];
alt tps.find(*ident) {
match tps.find(*ident) {
some(f) => f(v),
none => ser_path(cx, tps, path, s, v)
}
@ -634,7 +634,7 @@ fn deser_ty(cx: ext_ctxt, tps: deser_tps_map,
let ext_cx = cx; // required for #ast{}
alt ty.node {
match ty.node {
ast::ty_nil => {
#ast{ $(d).read_nil() }
}
@ -709,7 +709,7 @@ fn deser_ty(cx: ext_ctxt, tps: deser_tps_map,
vec::is_empty(path.types) {
let ident = path.idents[0];
alt tps.find(*ident) {
match tps.find(*ident) {
some(f) => f(),
none => deser_path(cx, tps, path, d)
}

22
src/libsyntax/ext/base.rs
View file

@ -150,7 +150,7 @@ fn mk_ctxt(parse_sess: parse::parse_sess,
fn mod_pop() { vec::pop(self.mod_path); }
fn mod_path() -> ~[ast::ident] { return self.mod_path; }
fn bt_push(ei: codemap::expn_info_) {
alt ei {
match ei {
expanded_from({call_site: cs, callie: callie}) => {
self.backtrace =
some(@expanded_from({
@ -161,7 +161,7 @@ fn mk_ctxt(parse_sess: parse::parse_sess,
}
}
fn bt_pop() {
alt self.backtrace {
match self.backtrace {
some(@expanded_from({call_site: {expn_info: prev, _}, _})) => {
self.backtrace = prev
}
@ -206,8 +206,8 @@ fn mk_ctxt(parse_sess: parse::parse_sess,
}
fn expr_to_str(cx: ext_ctxt, expr: @ast::expr, error: ~str) -> ~str {
alt expr.node {
ast::expr_lit(l) => alt l.node {
match expr.node {
ast::expr_lit(l) => match l.node {
ast::lit_str(s) => return *s,
_ => cx.span_fatal(l.span, error)
}
@ -216,7 +216,7 @@ fn expr_to_str(cx: ext_ctxt, expr: @ast::expr, error: ~str) -> ~str {
}
fn expr_to_ident(cx: ext_ctxt, expr: @ast::expr, error: ~str) -> ast::ident {
alt expr.node {
match expr.node {
ast::expr_path(p) => {
if vec::len(p.types) > 0u || vec::len(p.idents) != 1u {
cx.span_fatal(expr.span, error);
@ -233,11 +233,11 @@ fn get_mac_args_no_max(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
fn get_mac_args(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
min: uint, max: option<uint>, name: ~str) -> ~[@ast::expr] {
alt arg {
some(expr) => alt expr.node {
match arg {
some(expr) => match expr.node {
ast::expr_vec(elts, _) => {
let elts_len = vec::len(elts);
alt max {
match max {
some(max) if ! (min <= elts_len && elts_len <= max) => {
cx.span_fatal(sp,
fmt!{"#%s takes between %u and %u arguments.",
@ -261,7 +261,7 @@ fn get_mac_args(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
fn get_mac_body(cx: ext_ctxt, sp: span, args: ast::mac_body)
-> ast::mac_body_
{
alt (args) {
match (args) {
some(body) => body,
none => cx.span_fatal(sp, ~"missing macro body")
}
@ -289,10 +289,10 @@ fn tt_args_to_original_flavor(cx: ext_ctxt, sp: span, arg: ~[ast::token_tree])
let arg_reader = new_tt_reader(cx.parse_sess().span_diagnostic,
cx.parse_sess().interner, none, arg);
let args =
alt parse_or_else(cx.parse_sess(), cx.cfg(), arg_reader as reader,
match parse_or_else(cx.parse_sess(), cx.cfg(), arg_reader as reader,
argument_gram).get(@~"arg") {
@matched_seq(s, _) => do s.map() |lf| {
alt lf {
match lf {
@matched_nonterminal(parse::token::nt_expr(arg)) => {
arg /* whew! list of exprs, here we come! */
}

2
src/libsyntax/ext/env.rs
View file

@ -16,7 +16,7 @@ fn expand_syntax_ext(cx: ext_ctxt, sp: codemap::span, arg: ast::mac_arg,
// option<str> rather than just an maybe-empty string.
let var = expr_to_str(cx, args[0], ~"#env requires a string");
alt os::getenv(var) {
match os::getenv(var) {
option::none => return mk_uniq_str(cx, sp, ~""),
option::some(s) => return mk_uniq_str(cx, sp, s)
}

26
src/libsyntax/ext/expand.rs
View file

@ -15,18 +15,18 @@ fn expand_expr(exts: hashmap<~str, syntax_extension>, cx: ext_ctxt,
orig: fn@(expr_, span, ast_fold) -> (expr_, span))
-> (expr_, span)
{
return alt e {
return match e {
// expr_mac should really be expr_ext or something; it's the
// entry-point for all syntax extensions.
expr_mac(mac) => {
// Old-style macros, for compatibility, will erase this whole
// block once we've transitioned.
alt mac.node {
match mac.node {
mac_invoc(pth, args, body) => {
assert (vec::len(pth.idents) > 0u);
let extname = pth.idents[0];
alt exts.find(*extname) {
match exts.find(*extname) {
none => {
cx.span_fatal(pth.span,
fmt!{"macro undefined: '%s'", *extname})
@ -69,13 +69,13 @@ fn expand_expr(exts: hashmap<~str, syntax_extension>, cx: ext_ctxt,
mac_invoc_tt(pth, tts) => {
assert (vec::len(pth.idents) == 1u);
let extname = pth.idents[0];
alt exts.find(*extname) {
match exts.find(*extname) {
none => {
cx.span_fatal(pth.span,
fmt!{"macro undefined: '%s'", *extname})
}
some(expr_tt({expander: exp, span: exp_sp})) => {
let expanded = alt exp(cx, mac.span, tts) {
let expanded = match exp(cx, mac.span, tts) {
mr_expr(e) => e,
_ => cx.span_fatal(
pth.span, fmt!{"non-expr macro in expr pos: %s",
@ -141,12 +141,12 @@ fn expand_mod_items(exts: hashmap<~str, syntax_extension>, cx: ext_ctxt,
// the item into a new set of items.
let new_items = do vec::flat_map(module_.items) |item| {
do vec::foldr(item.attrs, ~[item]) |attr, items| {
let mname = alt attr.node.value.node {
let mname = match attr.node.value.node {
ast::meta_word(n) => n,
ast::meta_name_value(n, _) => n,
ast::meta_list(n, _) => n
};
alt exts.find(*mname) {
match exts.find(*mname) {
none | some(normal(_)) | some(macro_defining(_))
| some(expr_tt(_)) | some(item_tt(*)) => items,
some(item_decorator(dec_fn)) => {
@ -166,16 +166,16 @@ fn expand_item(exts: hashmap<~str, syntax_extension>,
orig: fn@(&&@ast::item, ast_fold) -> option<@ast::item>)
-> option<@ast::item>
{
let is_mod = alt it.node {
let is_mod = match it.node {
ast::item_mod(_) | ast::item_foreign_mod(_) => true,
_ => false
};
let maybe_it = alt it.node {
let maybe_it = match it.node {
ast::item_mac(*) => expand_item_mac(exts, cx, it, fld),
_ => some(it)
};
alt maybe_it {
match maybe_it {
some(it) => {
if is_mod { cx.mod_push(it.ident); }
let ret_val = orig(it, fld);
@ -192,10 +192,10 @@ fn expand_item(exts: hashmap<~str, syntax_extension>,
fn expand_item_mac(exts: hashmap<~str, syntax_extension>,
cx: ext_ctxt, &&it: @ast::item,
fld: ast_fold) -> option<@ast::item> {
alt it.node {
match it.node {
item_mac({node: mac_invoc_tt(pth, tts), span}) => {
let extname = pth.idents[0];
alt exts.find(*extname) {
match exts.find(*extname) {
none => {
cx.span_fatal(pth.span,
fmt!{"macro undefined: '%s'", *extname})
@ -205,7 +205,7 @@ fn expand_item_mac(exts: hashmap<~str, syntax_extension>,
cx.bt_push(expanded_from({call_site: it.span,
callie: {name: *extname,
span: expand.span}}));
let maybe_it = alt expanded {
let maybe_it = match expanded {
mr_item(it) => fld.fold_item(it),
mr_expr(e) => cx.span_fatal(pth.span,
~"expr macro in item position: " +

40
src/libsyntax/ext/fmt.rs
View file

@ -52,7 +52,7 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
fn make_flags(cx: ext_ctxt, sp: span, flags: ~[flag]) -> @ast::expr {
let mut tmp_expr = make_rt_path_expr(cx, sp, @~"flag_none");
for flags.each |f| {
let fstr = alt f {
let fstr = match f {
flag_left_justify => ~"flag_left_justify",
flag_left_zero_pad => ~"flag_left_zero_pad",
flag_space_for_sign => ~"flag_space_for_sign",
@ -65,7 +65,7 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
return tmp_expr;
}
fn make_count(cx: ext_ctxt, sp: span, cnt: count) -> @ast::expr {
alt cnt {
match cnt {
count_implied => {
return make_rt_path_expr(cx, sp, @~"count_implied");
}
@ -80,8 +80,8 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
}
fn make_ty(cx: ext_ctxt, sp: span, t: ty) -> @ast::expr {
let mut rt_type;
alt t {
ty_hex(c) => alt c {
match t {
ty_hex(c) => match c {
case_upper => rt_type = ~"ty_hex_upper",
case_lower => rt_type = ~"ty_hex_lower"
}
@ -121,8 +121,8 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
// FIXME: Move validation code into core::extfmt (Issue #2249)
fn is_signed_type(cnv: conv) -> bool {
alt cnv.ty {
ty_int(s) => alt s {
match cnv.ty {
ty_int(s) => match s {
signed => return true,
unsigned => return false
}
@ -131,12 +131,12 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
}
}
let unsupported = ~"conversion not supported in #fmt string";
alt cnv.param {
match cnv.param {
option::none => (),
_ => cx.span_unimpl(sp, unsupported)
}
for cnv.flags.each |f| {
alt f {
match f {
flag_left_justify => (),
flag_sign_always => {
if !is_signed_type(cnv) {
@ -156,19 +156,19 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
_ => cx.span_unimpl(sp, unsupported)
}
}
alt cnv.width {
match cnv.width {
count_implied => (),
count_is(_) => (),
_ => cx.span_unimpl(sp, unsupported)
}
alt cnv.precision {
match cnv.precision {
count_implied => (),
count_is(_) => (),
_ => cx.span_unimpl(sp, unsupported)
}
alt cnv.ty {
match cnv.ty {
ty_str => return make_conv_call(cx, arg.span, ~"str", cnv, arg),
ty_int(sign) => alt sign {
ty_int(sign) => match sign {
signed => return make_conv_call(cx, arg.span, ~"int", cnv, arg),
unsigned => {
return make_conv_call(cx, arg.span, ~"uint", cnv, arg)
@ -188,12 +188,12 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
}
}
fn log_conv(c: conv) {
alt c.param {
match c.param {
some(p) => { log(debug, ~"param: " + int::to_str(p, 10u)); }
_ => debug!{"param: none"}
}
for c.flags.each |f| {
alt f {
match f {
flag_left_justify => debug!{"flag: left justify"},
flag_left_zero_pad => debug!{"flag: left zero pad"},
flag_space_for_sign => debug!{"flag: left space pad"},
@ -201,7 +201,7 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
flag_alternate => debug!{"flag: alternate"}
}
}
alt c.width {
match c.width {
count_is(i) => log(
debug, ~"width: count is " + int::to_str(i, 10u)),
count_is_param(i) => log(
@ -209,7 +209,7 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
count_is_next_param => debug!{"width: count is next param"},
count_implied => debug!{"width: count is implied"}
}
alt c.precision {
match c.precision {
count_is(i) => log(
debug, ~"prec: count is " + int::to_str(i, 10u)),
count_is_param(i) => log(
@ -217,16 +217,16 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
count_is_next_param => debug!{"prec: count is next param"},
count_implied => debug!{"prec: count is implied"}
}
alt c.ty {
match c.ty {
ty_bool => debug!{"type: bool"},
ty_str => debug!{"type: str"},
ty_char => debug!{"type: char"},
ty_int(s) => alt s {
ty_int(s) => match s {
signed => debug!{"type: signed"},
unsigned => debug!{"type: unsigned"}
}
ty_bits => debug!{"type: bits"},
ty_hex(cs) => alt cs {
ty_hex(cs) => match cs {
case_upper => debug!{"type: uhex"},
case_lower => debug!{"type: lhex"},
}
@ -240,7 +240,7 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
let mut piece_exprs = ~[];
let nargs = args.len();
for pieces.each |pc| {
alt pc {
match pc {
piece_string(s) => {
vec::push(piece_exprs, mk_uniq_str(cx, fmt_sp, s))
}

2
src/libsyntax/ext/pipes/check.rs
View file

@ -44,7 +44,7 @@ impl proto_check of proto::visitor<(), (), ()> for ext_ctxt {
fn visit_message(name: ident, _span: span, _tys: &[@ast::ty],
this: state, next: next_state) {
alt next {
match next {
some({state: next, tys: next_tys}) => {
let proto = this.proto;
if !proto.has_state(next) {

6
src/libsyntax/ext/pipes/parse_proto.rs
View file

@ -25,12 +25,12 @@ impl proto_parser of proto_parser for parser {
fn parse_state(proto: protocol) {
let id = self.parse_ident();
self.expect(token::COLON);
let dir = alt copy self.token {
let dir = match copy self.token {
token::IDENT(n, _) => self.get_str(n),
_ => fail
};
self.bump();
let dir = alt dir {
let dir = match dir {
@~"send" => send,
@~"recv" => recv,
_ => fail
@ -64,7 +64,7 @@ impl proto_parser of proto_parser for parser {
self.expect(token::RARROW);
let next = alt copy self.token {
let next = match copy self.token {
token::IDENT(_, _) => {
let name = self.parse_ident();
let ntys = if self.token == token::LT {

22
src/libsyntax/ext/pipes/pipec.rs
View file

@ -47,7 +47,7 @@ trait gen_init {
impl compile of gen_send for message {
fn gen_send(cx: ext_ctxt) -> @ast::item {
debug!{"pipec: gen_send"};
alt self {
match self {
message(id, span, tys, this,
some({state: next, tys: next_tys})) => {
debug!{"pipec: next state exists"};
@ -71,7 +71,7 @@ impl compile of gen_send for message {
let mut body = ~"{\n";
if this.proto.is_bounded() {
let (sp, rp) = alt (this.dir, next.dir) {
let (sp, rp) = match (this.dir, next.dir) {
(send, send) => (~"c", ~"s"),
(send, recv) => (~"s", ~"c"),
(recv, send) => (~"s", ~"c"),
@ -87,7 +87,7 @@ impl compile of gen_send for message {
rp, *next.name};
}
else {
let pat = alt (this.dir, next.dir) {
let pat = match (this.dir, next.dir) {
(send, send) => ~"(c, s)",
(send, recv) => ~"(s, c)",
(recv, send) => ~"(s, c)",
@ -181,12 +181,12 @@ impl compile of to_type_decls for state {
for self.messages.each |m| {
let message(name, _span, tys, this, next) = m;
let tys = alt next {
let tys = match next {
some({state: next, tys: next_tys}) => {
let next = this.proto.get_state(next);
let next_name = next.data_name();
let dir = alt this.dir {
let dir = match this.dir {
send => @~"server",
recv => @~"client"
};
@ -208,7 +208,7 @@ impl compile of to_type_decls for state {
fn to_endpoint_decls(cx: ext_ctxt, dir: direction) -> ~[@ast::item] {
debug!{"pipec: to_endpoint_decls"};
let dir = alt dir {
let dir = match dir {
send => (*self).dir,
recv => (*self).dir.reverse()
};
@ -255,7 +255,7 @@ impl compile of gen_init for protocol {
let start_state = self.states[0];
let body = if !self.is_bounded() {
alt start_state.dir {
match start_state.dir {
send => #ast { pipes::entangle() },
recv => {
#ast {{
@ -267,7 +267,7 @@ impl compile of gen_init for protocol {
}
else {
let body = self.gen_init_bounded(ext_cx);
alt start_state.dir {
match start_state.dir {
send => body,
recv => {
#ast {{
@ -322,7 +322,7 @@ impl compile of gen_init for protocol {
let mut params: ~[ast::ty_param] = ~[];
for (copy self.states).each |s| {
for s.ty_params.each |tp| {
alt params.find(|tpp| *tp.ident == *tpp.ident) {
match params.find(|tpp| *tp.ident == *tpp.ident) {
none => vec::push(params, tp),
_ => ()
}
@ -338,7 +338,7 @@ impl compile of gen_init for protocol {
let mut params: ~[ast::ty_param] = ~[];
let fields = do (copy self.states).map_to_vec |s| {
for s.ty_params.each |tp| {
alt params.find(|tpp| *tp.ident == *tpp.ident) {
match params.find(|tpp| *tp.ident == *tpp.ident) {
none => vec::push(params, tp),
_ => ()
}
@ -439,7 +439,7 @@ impl parse_utils of ext_ctxt_parse_utils for ext_ctxt {
self.cfg(),
~[],
self.parse_sess());
alt res {
match res {
some(ast) => ast,
none => {
error!{"Parse error with ```\n%s\n```", s};

12
src/libsyntax/ext/pipes/proto.rs
View file

@ -11,7 +11,7 @@ enum direction {
impl of to_str for direction {
fn to_str() -> ~str {
alt self {
match self {
send => ~"send",
recv => ~"recv"
}
@ -20,7 +20,7 @@ impl of to_str for direction {
impl methods for direction {
fn reverse() -> direction {
alt self {
match self {
send => recv,
recv => send
}
@ -36,20 +36,20 @@ enum message {
impl methods for message {
fn name() -> ident {
alt self {
match self {
message(id, _, _, _, _) => id
}
}
fn span() -> span {
alt self {
match self {
message(_, span, _, _, _) => span
}
}
/// Return the type parameters actually used by this message
fn get_params() -> ~[ast::ty_param] {
alt self {
match self {
message(_, _, _, this, _) => this.ty_params
}
}
@ -92,7 +92,7 @@ impl methods for state {
/// from this state.
fn reachable(f: fn(state) -> bool) {
for self.messages.each |m| {
alt m {
match m {
message(_, _, _, _, some({state: id, _})) => {
let state = self.proto.get_state(id);
if !f(state) { break }

24
src/libsyntax/ext/qquote.rs
View file

@ -48,7 +48,7 @@ impl of qq_helper for @ast::expr {
fn span() -> span {self.span}
fn visit(cx: aq_ctxt, v: vt<aq_ctxt>) {visit_expr(self, cx, v);}
fn extract_mac() -> option<ast::mac_> {
alt (self.node) {
match (self.node) {
ast::expr_mac({node: mac, _}) => some(mac),
_ => none
}
@ -63,7 +63,7 @@ impl of qq_helper for @ast::ty {
fn span() -> span {self.span}
fn visit(cx: aq_ctxt, v: vt<aq_ctxt>) {visit_ty(self, cx, v);}
fn extract_mac() -> option<ast::mac_> {
alt (self.node) {
match (self.node) {
ast::ty_mac({node: mac, _}) => some(mac),
_ => none
}
@ -124,7 +124,7 @@ fn gather_anti_quotes<N: qq_helper>(lo: uint, node: N) -> aq_ctxt
fn visit_aq<T:qq_helper>(node: T, constr: ~str, &&cx: aq_ctxt, v: vt<aq_ctxt>)
{
alt (node.extract_mac()) {
match (node.extract_mac()) {
some(mac_aq(sp, e)) => {
cx.gather.push(gather_item {
lo: sp.lo - cx.lo,
@ -147,7 +147,7 @@ fn expand_ast(ecx: ext_ctxt, _sp: span,
let mut what = ~"expr";
do option::iter(arg) |arg| {
let args: ~[@ast::expr] =
alt arg.node {
match arg.node {
ast::expr_vec(elts, _) => elts,
_ => {
ecx.span_fatal
@ -157,7 +157,7 @@ fn expand_ast(ecx: ext_ctxt, _sp: span,
if vec::len::<@ast::expr>(args) != 1u {
ecx.span_fatal(_sp, ~"#ast requires exactly one arg");
}
alt (args[0].node) {
match (args[0].node) {
ast::expr_path(@{idents: id, _}) if vec::len(id) == 1u
=> what = *id[0],
_ => ecx.span_fatal(args[0].span, ~"expected an identifier")
@ -165,7 +165,7 @@ fn expand_ast(ecx: ext_ctxt, _sp: span,
}
let body = get_mac_body(ecx,_sp,body);
return alt what {
return match what {
~"crate" => finish(ecx, body, parse_crate),
~"expr" => finish(ecx, body, parse_expr),
~"ty" => finish(ecx, body, parse_ty),
@ -183,7 +183,7 @@ fn parse_expr(p: parser) -> @ast::expr { p.parse_expr() }
fn parse_pat(p: parser) -> @ast::pat { p.parse_pat(true) }
fn parse_item(p: parser) -> @ast::item {
alt p.parse_item(~[]) {
match p.parse_item(~[]) {
some(item) => item,
none => fail ~"parse_item: parsing an item failed"
}
@ -225,7 +225,7 @@ fn finish<T: qq_helper>
state = skip(str::char_len(repl));
str2 += repl;
}
alt copy state {
match copy state {
active => str::push_char(str2, ch),
skip(1u) => state = blank,
skip(sk) => state = skip (sk-1u),
@ -308,8 +308,8 @@ fn replace_expr(repls: ~[fragment],
orig: fn@(ast::expr_, span, ast_fold)->(ast::expr_, span))
-> (ast::expr_, span)
{
alt e {
ast::expr_mac({node: mac_var(i), _}) => alt (repls[i]) {
match e {
ast::expr_mac({node: mac_var(i), _}) => match (repls[i]) {
from_expr(r) => (r.node, r.span),
_ => fail /* fixme error message */
}
@ -322,8 +322,8 @@ fn replace_ty(repls: ~[fragment],
orig: fn@(ast::ty_, span, ast_fold)->(ast::ty_, span))
-> (ast::ty_, span)
{
alt e {
ast::ty_mac({node: mac_var(i), _}) => alt (repls[i]) {
match e {
ast::ty_mac({node: mac_var(i), _}) => match (repls[i]) {
from_ty(r) => (r.node, r.span),
_ => fail /* fixme error message */
}

112
src/libsyntax/ext/simplext.rs
View file

@ -36,7 +36,7 @@ enum matchable {
/* for when given an incompatible bit of AST */
fn match_error(cx: ext_ctxt, m: matchable, expected: ~str) -> ! {
alt m {
match m {
match_expr(x) => cx.span_fatal(
x.span, ~"this argument is an expr, expected " + expected),
match_path(x) => cx.span_fatal(
@ -65,8 +65,8 @@ fn elts_to_ell(cx: ext_ctxt, elts: ~[@expr]) ->
let mut idx: uint = 0u;
let mut res = none;
for elts.each |elt| {
alt elt.node {
expr_mac(m) => alt m.node {
match elt.node {
expr_mac(m) => match m.node {
ast::mac_ellipsis => {
if res != none {
cx.span_fatal(m.span, ~"only one ellipsis allowed");
@ -82,7 +82,7 @@ fn elts_to_ell(cx: ext_ctxt, elts: ~[@expr]) ->
}
idx += 1u;
}
return alt res {
return match res {
some(val) => val,
none => {pre: elts, rep: none, post: ~[]}
}
@ -92,7 +92,7 @@ fn option_flatten_map<T: copy, U: copy>(f: fn@(T) -> option<U>, v: ~[T]) ->
option<~[U]> {
let mut res = ~[];
for v.each |elem| {
alt f(elem) {
match f(elem) {
none => return none,
some(fv) => vec::push(res, fv)
}
@ -101,9 +101,9 @@ fn option_flatten_map<T: copy, U: copy>(f: fn@(T) -> option<U>, v: ~[T]) ->
}
fn a_d_map(ad: arb_depth<matchable>, f: selector) -> match_result {
alt ad {
match ad {
leaf(x) => return f(x),
seq(ads, span) => alt option_flatten_map(|x| a_d_map(x, f), *ads) {
seq(ads, span) => match option_flatten_map(|x| a_d_map(x, f), *ads) {
none => return none,
some(ts) => return some(seq(@ts, span))
}
@ -112,7 +112,7 @@ fn a_d_map(ad: arb_depth<matchable>, f: selector) -> match_result {
fn compose_sels(s1: selector, s2: selector) -> selector {
fn scomp(s1: selector, s2: selector, m: matchable) -> match_result {
return alt s1(m) {
return match s1(m) {
none => none,
some(matches) => a_d_map(matches, s2)
}
@ -156,11 +156,11 @@ fn use_selectors_to_bind(b: binders, e: @expr) -> option<bindings> {
let res = box_str_hash::<arb_depth<matchable>>();
//need to do this first, to check vec lengths.
for b.literal_ast_matchers.each |sel| {
alt sel(match_expr(e)) { none => return none, _ => () }
match sel(match_expr(e)) { none => return none, _ => () }
}
let mut never_mind: bool = false;
for b.real_binders.each |key, val| {
alt val(match_expr(e)) {
match val(match_expr(e)) {
none => never_mind = true,
some(mtc) => { res.insert(key, mtc); }
}
@ -209,7 +209,7 @@ fn follow(m: arb_depth<matchable>, idx_path: @mut ~[uint]) ->
arb_depth<matchable> {
let mut res: arb_depth<matchable> = m;
for vec::each(*idx_path) |idx| {
res = alt res {
res = match res {
leaf(_) => return res,/* end of the line */
seq(new_ms, _) => new_ms[idx]
}
@ -219,10 +219,10 @@ fn follow(m: arb_depth<matchable>, idx_path: @mut ~[uint]) ->
fn follow_for_trans(cx: ext_ctxt, mmaybe: option<arb_depth<matchable>>,
idx_path: @mut ~[uint]) -> option<matchable> {
alt mmaybe {
match mmaybe {
none => return none,
some(m) => {
return alt follow(m, idx_path) {
return match follow(m, idx_path) {
seq(_, sp) => {
cx.span_fatal(sp,
~"syntax matched under ... but not " +
@ -258,10 +258,10 @@ fn free_vars(b: bindings, e: @expr, it: fn(ident)) {
fn transcribe_exprs(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint],
recur: fn@(&&@expr) -> @expr,
exprs: ~[@expr]) -> ~[@expr] {
alt elts_to_ell(cx, exprs) {
match elts_to_ell(cx, exprs) {
{pre: pre, rep: repeat_me_maybe, post: post} => {
let mut res = vec::map(pre, recur);
alt repeat_me_maybe {
match repeat_me_maybe {
none => (),
some(repeat_me) => {
let mut repeat: option<{rep_count: uint, name: ident}> = none;
@ -269,10 +269,10 @@ fn transcribe_exprs(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint],
the leaves, which are just duplicated */
do free_vars(b, repeat_me) |fv| {
let cur_pos = follow(b.get(fv), idx_path);
alt cur_pos {
match cur_pos {
leaf(_) => (),
seq(ms, _) => {
alt repeat {
match repeat {
none => {
repeat = some({rep_count: vec::len(*ms), name: fv});
}
@ -290,7 +290,7 @@ fn transcribe_exprs(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint],
}
}
};
alt repeat {
match repeat {
none => {
cx.span_fatal(repeat_me.span,
~"'...' surrounds an expression without any" +
@ -320,7 +320,7 @@ fn transcribe_exprs(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint],
// substitute, in a position that's required to be an ident
fn transcribe_ident(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint],
&&i: ident, _fld: ast_fold) -> ident {
return alt follow_for_trans(cx, b.find(i), idx_path) {
return match follow_for_trans(cx, b.find(i), idx_path) {
some(match_ident(a_id)) => a_id.node,
some(m) => match_error(cx, m, ~"an identifier"),
none => i
@ -332,7 +332,7 @@ fn transcribe_path(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint],
p: path, _fld: ast_fold) -> path {
// Don't substitute into qualified names.
if vec::len(p.types) > 0u || vec::len(p.idents) != 1u { return p; }
alt follow_for_trans(cx, b.find(p.idents[0]), idx_path) {
match follow_for_trans(cx, b.find(p.idents[0]), idx_path) {
some(match_ident(id)) => {
{span: id.span, global: false, idents: ~[id.node],
rp: none, types: ~[]}
@ -349,13 +349,13 @@ fn transcribe_expr(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint],
orig: fn@(ast::expr_, span, ast_fold)->(ast::expr_, span))
-> (ast::expr_, span)
{
return alt e {
return match e {
expr_path(p) => {
// Don't substitute into qualified names.
if vec::len(p.types) > 0u || vec::len(p.idents) != 1u {
(e, s);
}
alt follow_for_trans(cx, b.find(p.idents[0]), idx_path) {
match follow_for_trans(cx, b.find(p.idents[0]), idx_path) {
some(match_ident(id)) => {
(expr_path(@{span: id.span,
global: false,
@ -378,11 +378,11 @@ fn transcribe_type(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint],
orig: fn@(ast::ty_, span, ast_fold) -> (ast::ty_, span))
-> (ast::ty_, span)
{
return alt t {
return match t {
ast::ty_path(pth, _) => {
alt path_to_ident(pth) {
match path_to_ident(pth) {
some(id) => {
alt follow_for_trans(cx, b.find(id), idx_path) {
match follow_for_trans(cx, b.find(id), idx_path) {
some(match_ty(ty)) => (ty.node, ty.span),
some(m) => match_error(cx, m, ~"a type"),
none => orig(t, s, fld)
@ -404,9 +404,9 @@ fn transcribe_block(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint],
orig: fn@(blk_, span, ast_fold) -> (blk_, span))
-> (blk_, span)
{
return alt block_to_ident(blk) {
return match block_to_ident(blk) {
some(id) => {
alt follow_for_trans(cx, b.find(id), idx_path) {
match follow_for_trans(cx, b.find(id), idx_path) {
some(match_block(new_blk)) => (new_blk.node, new_blk.span),
// possibly allow promotion of ident/path/expr to blocks?
@ -424,12 +424,12 @@ argument. ps accumulates instructions on navigating the tree.*/
fn p_t_s_rec(cx: ext_ctxt, m: matchable, s: selector, b: binders) {
//it might be possible to traverse only exprs, not matchables
alt m {
match m {
match_expr(e) => {
alt e.node {
match e.node {
expr_path(p_pth) => p_t_s_r_path(cx, p_pth, s, b),
expr_vec(p_elts, _) => {
alt elts_to_ell(cx, p_elts) {
match elts_to_ell(cx, p_elts) {
{pre: pre, rep: some(repeat_me), post: post} => {
p_t_s_r_length(cx, vec::len(pre) + vec::len(post), true, s,
b);
@ -459,7 +459,7 @@ fn p_t_s_rec(cx: ext_ctxt, m: matchable, s: selector, b: binders) {
_ => {
fn select(cx: ext_ctxt, m: matchable, pat: @expr) ->
match_result {
return alt m {
return match m {
match_expr(e) => {
if e == pat { some(leaf(match_exact)) } else { none }
}
@ -477,11 +477,11 @@ fn p_t_s_rec(cx: ext_ctxt, m: matchable, s: selector, b: binders) {
/* make a match more precise */
fn specialize_match(m: matchable) -> matchable {
return alt m {
return match m {
match_expr(e) => {
alt e.node {
match e.node {
expr_path(pth) => {
alt path_to_ident(pth) {
match path_to_ident(pth) {
some(id) => match_ident(respan(pth.span, id)),
none => match_path(pth)
}
@ -495,10 +495,10 @@ fn specialize_match(m: matchable) -> matchable {
/* pattern_to_selectors helper functions */
fn p_t_s_r_path(cx: ext_ctxt, p: @path, s: selector, b: binders) {
alt path_to_ident(p) {
match path_to_ident(p) {
some(p_id) => {
fn select(cx: ext_ctxt, m: matchable) -> match_result {
return alt m {
return match m {
match_expr(e) => some(leaf(specialize_match(m))),
_ => cx.bug(~"broken traversal in p_t_s_r")
}
@ -514,8 +514,8 @@ fn p_t_s_r_path(cx: ext_ctxt, p: @path, s: selector, b: binders) {
fn block_to_ident(blk: blk_) -> option<ident> {
if vec::len(blk.stmts) != 0u { return none; }
return alt blk.expr {
some(expr) => alt expr.node {
return match blk.expr {
some(expr) => match expr.node {
expr_path(pth) => path_to_ident(pth),
_ => none
}
@ -526,8 +526,8 @@ fn block_to_ident(blk: blk_) -> option<ident> {
fn p_t_s_r_mac(cx: ext_ctxt, mac: ast::mac, _s: selector, _b: binders) {
fn select_pt_1(cx: ext_ctxt, m: matchable,
fn_m: fn(ast::mac) -> match_result) -> match_result {
return alt m {
match_expr(e) => alt e.node {
return match m {
match_expr(e) => match e.node {
expr_mac(mac) => fn_m(mac),
_ => none
}
@ -537,7 +537,7 @@ fn p_t_s_r_mac(cx: ext_ctxt, mac: ast::mac, _s: selector, _b: binders) {
fn no_des(cx: ext_ctxt, sp: span, syn: ~str) -> ! {
cx.span_fatal(sp, ~"destructuring " + syn + ~" is not yet supported");
}
alt mac.node {
match mac.node {
ast::mac_ellipsis => cx.span_fatal(mac.span, ~"misused `...`"),
ast::mac_invoc(_, _, _) => no_des(cx, mac.span, ~"macro calls"),
ast::mac_invoc_tt(_, _) => no_des(cx, mac.span, ~"macro calls"),
@ -550,9 +550,9 @@ fn p_t_s_r_ellipses(cx: ext_ctxt, repeat_me: @expr, offset: uint, s: selector,
b: binders) {
fn select(cx: ext_ctxt, repeat_me: @expr, offset: uint, m: matchable) ->
match_result {
return alt m {
return match m {
match_expr(e) => {
alt e.node {
match e.node {
expr_vec(arg_elts, _) => {
let mut elts = ~[];
let mut idx = offset;
@ -580,9 +580,9 @@ fn p_t_s_r_length(cx: ext_ctxt, len: uint, at_least: bool, s: selector,
b: binders) {
fn len_select(_cx: ext_ctxt, m: matchable, at_least: bool, len: uint) ->
match_result {
return alt m {
return match m {
match_expr(e) => {
alt e.node {
match e.node {
expr_vec(arg_elts, _) => {
let actual_len = vec::len(arg_elts);
if at_least && actual_len >= len || actual_len == len {
@ -604,9 +604,9 @@ fn p_t_s_r_actual_vector(cx: ext_ctxt, elts: ~[@expr], _repeat_after: bool,
let mut idx: uint = 0u;
while idx < vec::len(elts) {
fn select(cx: ext_ctxt, m: matchable, idx: uint) -> match_result {
return alt m {
return match m {
match_expr(e) => {
alt e.node {
match e.node {
expr_vec(arg_elts, _) => {
some(leaf(match_expr(arg_elts[idx])))
}
@ -629,7 +629,7 @@ fn add_new_extension(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
let mut macro_name: option<@~str> = none;
let mut clauses: ~[@clause] = ~[];
for args.each |arg| {
alt arg.node {
match arg.node {
expr_vec(elts, mutbl) => {
if vec::len(elts) != 2u {
cx.span_fatal((*arg).span,
@ -638,12 +638,12 @@ fn add_new_extension(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
}
alt elts[0u].node {
match elts[0u].node {
expr_mac(mac) => {
alt mac.node {
match mac.node {
mac_invoc(pth, invoc_arg, body) => {
alt path_to_ident(pth) {
some(id) => alt macro_name {
match path_to_ident(pth) {
some(id) => match macro_name {
none => macro_name = some(id),
some(other_id) => if id != other_id {
cx.span_fatal(pth.span,
@ -654,7 +654,7 @@ fn add_new_extension(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
none => cx.span_fatal(pth.span,
~"macro name must not be a path")
}
let arg = alt invoc_arg {
let arg = match invoc_arg {
some(arg) => arg,
none => cx.span_fatal(mac.span,
~"macro must have arguments")
@ -689,7 +689,7 @@ fn add_new_extension(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
let ext = |a,b,c,d, move clauses| generic_extension(a,b,c,d,clauses);
return {ident:
alt macro_name {
match macro_name {
some(id) => id,
none => cx.span_fatal(sp, ~"macro definition must have " +
~"at least one clause")
@ -699,12 +699,12 @@ fn add_new_extension(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
fn generic_extension(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
_body: ast::mac_body,
clauses: ~[@clause]) -> @expr {
let arg = alt arg {
let arg = match arg {
some(arg) => arg,
none => cx.span_fatal(sp, ~"macro must have arguments")
};
for clauses.each |c| {
alt use_selectors_to_bind(c.params, arg) {
match use_selectors_to_bind(c.params, arg) {
some(bindings) => return transcribe(cx, bindings, c.body),
none => again
}

4
src/libsyntax/ext/source_util.rs
View file

@ -70,7 +70,7 @@ fn expand_include_str(cx: ext_ctxt, sp: codemap::span, arg: ast::mac_arg,
let file = expr_to_str(cx, args[0], ~"#include_str requires a string");
let res = io::read_whole_file_str(res_rel_file(cx, sp, file));
alt res {
match res {
result::ok(_) => { /* Continue. */ }
result::err(e) => {
cx.parse_sess().span_diagnostic.handler().fatal(e);
@ -86,7 +86,7 @@ fn expand_include_bin(cx: ext_ctxt, sp: codemap::span, arg: ast::mac_arg,
let file = expr_to_str(cx, args[0], ~"#include_bin requires a string");
alt io::read_whole_file(res_rel_file(cx, sp, file)) {
match io::read_whole_file(res_rel_file(cx, sp, file)) {
result::ok(src) => {
let u8_exprs = vec::map(src, |char: u8| {
mk_u8(cx, sp, char)

26
src/libsyntax/ext/tt/earley_parser.rs
View file

@ -31,7 +31,7 @@ enum matcher_pos_up { /* to break a circularity */
}
fn is_some(&&mpu: matcher_pos_up) -> bool {
alt mpu {
match mpu {
matcher_pos_up(none) => false,
_ => true
}
@ -48,7 +48,7 @@ type matcher_pos = ~{
};
fn copy_up(&& mpu: matcher_pos_up) -> matcher_pos {
alt mpu {
match mpu {
matcher_pos_up(some(mp)) => copy mp,
_ => fail
}
@ -56,7 +56,7 @@ fn copy_up(&& mpu: matcher_pos_up) -> matcher_pos {
fn count_names(ms: &[matcher]) -> uint {
vec::foldl(0u, ms, |ct, m| {
ct + alt m.node {
ct + match m.node {
match_tok(_) => 0u,
match_seq(more_ms, _, _, _, _) => count_names(more_ms),
match_nonterminal(_,_,_) => 1u
@ -68,7 +68,7 @@ fn initial_matcher_pos(ms: ~[matcher], sep: option<token>, lo: uint)
-> matcher_pos {
let mut match_idx_hi = 0u;
for ms.each() |elt| {
alt elt.node {
match elt.node {
match_tok(_) => (),
match_seq(_,_,_,_,hi) => {
match_idx_hi = hi; // it is monotonic...
@ -113,7 +113,7 @@ fn nameize(p_s: parse_sess, ms: ~[matcher], res: ~[@named_match])
-> hashmap<ident,@named_match> {
fn n_rec(p_s: parse_sess, m: matcher, res: ~[@named_match],
ret_val: hashmap<ident, @named_match>) {
alt m {
match m {
{node: match_tok(_), span: _} => (),
{node: match_seq(more_ms, _, _, _, _), span: _} => {
for more_ms.each() |next_m| { n_rec(p_s, next_m, res, ret_val) };
@ -139,7 +139,7 @@ enum parse_result {
fn parse_or_else(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader,
ms: ~[matcher]) -> hashmap<ident, @named_match> {
alt parse(sess, cfg, rdr, ms) {
match parse(sess, cfg, rdr, ms) {
success(m) => m,
failure(sp, str) => sess.span_diagnostic.span_fatal(sp, str)
}
@ -202,7 +202,7 @@ fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher])
// can we go around again?
// the *_t vars are workarounds for the lack of unary move
alt copy ei.sep {
match copy ei.sep {
some(t) if idx == len => { // we need a separator
if tok == t { //pass the separator
let ei_t <- ei;
@ -220,7 +220,7 @@ fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher])
vec::push(eof_eis, ei);
}
} else {
alt copy ei.elts[idx].node {
match copy ei.elts[idx].node {
/* need to descend into sequence */
match_seq(matchers, sep, zero_ok,
match_idx_lo, match_idx_hi) => {
@ -270,7 +270,7 @@ fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher])
if (bb_eis.len() > 0u && next_eis.len() > 0u)
|| bb_eis.len() > 1u {
let nts = str::connect(vec::map(bb_eis, |ei| {
alt ei.elts[ei.idx].node {
match ei.elts[ei.idx].node {
match_nonterminal(bind,name,_) => {
fmt!{"%s ('%s')", *name, *bind}
}
@ -293,7 +293,7 @@ fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher])
let rust_parser = parser(sess, cfg, rdr.dup(), SOURCE_FILE);
let ei = vec::pop(bb_eis);
alt ei.elts[ei.idx].node {
match ei.elts[ei.idx].node {
match_nonterminal(_, name, idx) => {
ei.matches[idx].push(@matched_nonterminal(
parse_nt(rust_parser, *name)));
@ -318,8 +318,8 @@ fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher])
}
fn parse_nt(p: parser, name: ~str) -> nonterminal {
alt name {
~"item" => alt p.parse_item(~[]) {
match name {
~"item" => match p.parse_item(~[]) {
some(i) => token::nt_item(i),
none => p.fatal(~"expected an item keyword")
}
@ -329,7 +329,7 @@ fn parse_nt(p: parser, name: ~str) -> nonterminal {
~"expr" => token::nt_expr(p.parse_expr()),
~"ty" => token::nt_ty(p.parse_ty(false /* no need to disambiguate*/)),
// this could be handled like a token, since it is one
~"ident" => alt copy p.token {
~"ident" => match copy p.token {
token::IDENT(sn,b) => { p.bump(); token::nt_ident(sn,b) }
_ => p.fatal(~"expected ident, found "
+ token::to_str(*p.reader.interner(), copy p.token))

11
src/libsyntax/ext/tt/macro_rules.rs
View file

@ -37,11 +37,11 @@ fn add_new_extension(cx: ext_ctxt, sp: span, name: ident,
arg_reader as reader, argument_gram);
// Extract the arguments:
let lhses:~[@named_match] = alt argument_map.get(@~"lhs") {
let lhses:~[@named_match] = match argument_map.get(@~"lhs") {
@matched_seq(s, sp) => s,
_ => cx.span_bug(sp, ~"wrong-structured lhs")
};
let rhses:~[@named_match] = alt argument_map.get(@~"rhs") {
let rhses:~[@named_match] = match argument_map.get(@~"rhs") {
@matched_seq(s, sp) => s,
_ => cx.span_bug(sp, ~"wrong-structured rhs")
};
@ -58,13 +58,14 @@ fn add_new_extension(cx: ext_ctxt, sp: span, name: ident,
let itr = cx.parse_sess().interner;
for lhses.eachi() |i, lhs| { // try each arm's matchers
alt lhs {
match lhs {
@matched_nonterminal(nt_matchers(mtcs)) => {
// `none` is because we're not interpolating
let arg_rdr = new_tt_reader(s_d, itr, none, arg) as reader;
alt parse(cx.parse_sess(), cx.cfg(), arg_rdr, mtcs) {
match parse(cx.parse_sess(), cx.cfg(), arg_rdr, mtcs) {
success(named_matches) => {
let rhs = alt rhses[i] { // okay, what's your transcriber?
let rhs = match rhses[i] {
// okay, what's your transcriber?
@matched_nonterminal(nt_tt(@tt)) => tt,
_ => cx.span_bug(sp, ~"bad thing in rhs")
};

24
src/libsyntax/ext/tt/transcribe.rs
View file

@ -46,7 +46,7 @@ fn new_tt_reader(sp_diag: span_handler, itr: @interner<@~str>,
let r = @{sp_diag: sp_diag, interner: itr,
mut cur: @{readme: src, mut idx: 0u, dotdotdoted: false,
sep: none, up: tt_frame_up(option::none)},
interpolations: alt interp { /* just a convienience */
interpolations: match interp { /* just a convienience */
none => std::map::box_str_hash::<@named_match>(),
some(x) => x
},
@ -61,7 +61,7 @@ fn new_tt_reader(sp_diag: span_handler, itr: @interner<@~str>,
pure fn dup_tt_frame(&&f: tt_frame) -> tt_frame {
@{readme: f.readme, mut idx: f.idx, dotdotdoted: f.dotdotdoted,
sep: f.sep, up: alt f.up {
sep: f.sep, up: match f.up {
tt_frame_up(some(up_frame)) => {
tt_frame_up(some(dup_tt_frame(up_frame)))
}
@ -82,7 +82,7 @@ pure fn dup_tt_reader(&&r: tt_reader) -> tt_reader {
pure fn lookup_cur_matched_by_matched(r: tt_reader,
start: @named_match) -> @named_match {
pure fn red(&&ad: @named_match, &&idx: uint) -> @named_match {
alt *ad {
match *ad {
matched_nonterminal(_) => {
// end of the line; duplicate henceforth
ad
@ -102,10 +102,10 @@ enum lis {
fn lockstep_iter_size(&&t: token_tree, &&r: tt_reader) -> lis {
fn lis_merge(lhs: lis, rhs: lis) -> lis {
alt lhs {
match lhs {
lis_unconstrained => rhs,
lis_contradiction(_) => lhs,
lis_constraint(l_len, l_id) => alt rhs {
lis_constraint(l_len, l_id) => match rhs {
lis_unconstrained => lhs,
lis_contradiction(_) => rhs,
lis_constraint(r_len, _) if l_len == r_len => lhs,
@ -117,13 +117,13 @@ fn lockstep_iter_size(&&t: token_tree, &&r: tt_reader) -> lis {
}
}
}
alt t {
match t {
tt_delim(tts) | tt_seq(_, tts, _, _) => {
vec::foldl(lis_unconstrained, tts, {|lis, tt|
lis_merge(lis, lockstep_iter_size(tt, r)) })
}
tt_tok(*) => lis_unconstrained,
tt_nonterminal(_, name) => alt *lookup_cur_matched(r, name) {
tt_nonterminal(_, name) => match *lookup_cur_matched(r, name) {
matched_nonterminal(_) => lis_unconstrained,
matched_seq(ads, _) => lis_constraint(ads.len(), name)
}
@ -138,7 +138,7 @@ fn tt_next_token(&&r: tt_reader) -> {tok: token, sp: span} {
if ! r.cur.dotdotdoted
|| r.repeat_idx.last() == r.repeat_len.last() - 1 {
alt r.cur.up {
match r.cur.up {
tt_frame_up(none) => {
r.cur_tok = EOF;
return ret_val;
@ -156,7 +156,7 @@ fn tt_next_token(&&r: tt_reader) -> {tok: token, sp: span} {
} else { /* repeat */
r.cur.idx = 0u;
r.repeat_idx[r.repeat_idx.len() - 1u] += 1u;
alt r.cur.sep {
match r.cur.sep {
some(tk) => {
r.cur_tok = tk; /* repeat same span, I guess */
return ret_val;
@ -167,7 +167,7 @@ fn tt_next_token(&&r: tt_reader) -> {tok: token, sp: span} {
}
loop { /* because it's easiest, this handles `tt_delim` not starting
with a `tt_tok`, even though it won't happen */
alt r.cur.readme[r.cur.idx] {
match r.cur.readme[r.cur.idx] {
tt_delim(tts) => {
r.cur = @{readme: tts, mut idx: 0u, dotdotdoted: false,
sep: none, up: tt_frame_up(option::some(r.cur)) };
@ -179,7 +179,7 @@ fn tt_next_token(&&r: tt_reader) -> {tok: token, sp: span} {
return ret_val;
}
tt_seq(sp, tts, sep, zerok) => {
alt lockstep_iter_size(tt_seq(sp, tts, sep, zerok), r) {
match lockstep_iter_size(tt_seq(sp, tts, sep, zerok), r) {
lis_unconstrained => {
r.sp_diag.span_fatal(
sp, /* blame macro writer */
@ -212,7 +212,7 @@ fn tt_next_token(&&r: tt_reader) -> {tok: token, sp: span} {
}
// FIXME #2887: think about span stuff here
tt_nonterminal(sp, ident) => {
alt *lookup_cur_matched(r, ident) {
match *lookup_cur_matched(r, ident) {
/* sidestep the interpolation tricks for ident because
(a) idents can be in lots of places, so it'd be a pain
(b) we actually can, since it's a token. */

34
src/libsyntax/fold.rs
View file

@ -80,7 +80,7 @@ type ast_fold_precursor = @{
//used in noop_fold_item and noop_fold_crate and noop_fold_crate_directive
fn fold_meta_item_(&&mi: @meta_item, fld: ast_fold) -> @meta_item {
return @{node:
alt mi.node {
match mi.node {
meta_word(id) => meta_word(fld.fold_ident(id)),
meta_list(id, mis) => {
let fold_meta_item = |x|fold_meta_item_(x, fld);
@ -112,7 +112,7 @@ fn fold_arg_(a: arg, fld: ast_fold) -> arg {
//used in noop_fold_expr, and possibly elsewhere in the future
fn fold_mac_(m: mac, fld: ast_fold) -> mac {
return {node:
alt m.node {
match m.node {
mac_invoc(pth, arg, body) => {
mac_invoc(fld.fold_path(pth),
option::map(arg, |x| fld.fold_expr(x)), body)
@ -133,7 +133,7 @@ fn fold_fn_decl(decl: ast::fn_decl, fld: ast_fold) -> ast::fn_decl {
}
fn fold_ty_param_bound(tpb: ty_param_bound, fld: ast_fold) -> ty_param_bound {
alt tpb {
match tpb {
bound_copy | bound_send | bound_const | bound_owned => tpb,
bound_trait(ty) => bound_trait(fld.fold_ty(ty))
}
@ -163,7 +163,7 @@ fn noop_fold_crate(c: crate_, fld: ast_fold) -> crate_ {
fn noop_fold_crate_directive(cd: crate_directive_, fld: ast_fold) ->
crate_directive_ {
return alt cd {
return match cd {
cdir_src_mod(id, attrs) => {
cdir_src_mod(fld.fold_ident(id), /* FIXME (#2543) */ copy attrs)
}
@ -190,7 +190,7 @@ fn noop_fold_foreign_item(&&ni: @foreign_item, fld: ast_fold)
return @{ident: fld.fold_ident(ni.ident),
attrs: vec::map(ni.attrs, fold_attribute),
node:
alt ni.node {
match ni.node {
foreign_item_fn(fdec, typms) => {
foreign_item_fn({inputs: vec::map(fdec.inputs, fold_arg),
output: fld.fold_ty(fdec.output),
@ -216,7 +216,7 @@ fn noop_fold_item(&&i: @item, fld: ast_fold) -> option<@item> {
fn noop_fold_class_item(&&ci: @class_member, fld: ast_fold)
-> @class_member {
@{node: alt ci.node {
@{node: match ci.node {
instance_var(ident, t, cm, id, p) => {
instance_var(/* FIXME (#2543) */ copy ident,
fld.fold_ty(t), cm, id, p)
@ -227,7 +227,7 @@ fn noop_fold_class_item(&&ci: @class_member, fld: ast_fold)
}
fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
return alt i {
return match i {
item_const(t, e) => item_const(fld.fold_ty(t), fld.fold_expr(e)),
item_fn(decl, typms, body) => {
item_fn(fold_fn_decl(decl, fld),
@ -244,7 +244,7 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
}
item_class(typms, traits, items, m_ctor, m_dtor) => {
let resulting_optional_constructor;
alt m_ctor {
match m_ctor {
none => {
resulting_optional_constructor = none;
}
@ -319,7 +319,7 @@ fn noop_fold_block(b: blk_, fld: ast_fold) -> blk_ {
}
fn noop_fold_stmt(s: stmt_, fld: ast_fold) -> stmt_ {
return alt s {
return match s {
stmt_decl(d, nid) => stmt_decl(fld.fold_decl(d), fld.new_id(nid)),
stmt_expr(e, nid) => stmt_expr(fld.fold_expr(e), fld.new_id(nid)),
stmt_semi(e, nid) => stmt_semi(fld.fold_expr(e), fld.new_id(nid))
@ -333,7 +333,7 @@ fn noop_fold_arm(a: arm, fld: ast_fold) -> arm {
}
fn noop_fold_pat(p: pat_, fld: ast_fold) -> pat_ {
return alt p {
return match p {
pat_wild => pat_wild,
pat_ident(binding_mode, pth, sub) => {
pat_ident(binding_mode,
@ -364,9 +364,9 @@ fn noop_fold_pat(p: pat_, fld: ast_fold) -> pat_ {
}
fn noop_fold_decl(d: decl_, fld: ast_fold) -> decl_ {
alt d {
match d {
decl_local(ls) => decl_local(vec::map(ls, |x| fld.fold_local(x))),
decl_item(it) => alt fld.fold_item(it) {
decl_item(it) => match fld.fold_item(it) {
some(it_folded) => decl_item(it_folded),
none => decl_local(~[])
}
@ -393,7 +393,7 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
let fold_mac = |x| fold_mac_(x, fld);
return alt e {
return match e {
expr_vstore(e, v) => {
expr_vstore(fld.fold_expr(e), v)
}
@ -496,7 +496,7 @@ fn noop_fold_ty(t: ty_, fld: ast_fold) -> ty_ {
mt: fold_mt(f.node.mt, fld)},
span: fld.new_span(f.span)}
}
alt t {
match t {
ty_nil | ty_bot | ty_infer => copy t,
ty_box(mt) => ty_box(fold_mt(mt, fld)),
ty_uniq(mt) => ty_uniq(fold_mt(mt, fld)),
@ -533,7 +533,7 @@ fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ {
let fold_attribute = |x| fold_attribute_(x, fld);
let attrs = vec::map(v.attrs, fold_attribute);
let de = alt v.disr_expr {
let de = match v.disr_expr {
some(e) => some(fld.fold_expr(e)),
none => none
};
@ -560,7 +560,7 @@ fn noop_fold_local(l: local_, fld: ast_fold) -> local_ {
ty: fld.fold_ty(l.ty),
pat: fld.fold_pat(l.pat),
init:
alt l.init {
match l.init {
option::none::<initializer> => l.init,
option::some::<initializer>(init) => {
option::some::<initializer>({op: init.op,
@ -635,7 +635,7 @@ impl of ast_fold for ast_fold_precursor {
return self.fold_item(i, self as ast_fold);
}
fn fold_class_item(&&ci: @class_member) -> @class_member {
@{node: alt ci.node {
@{node: match ci.node {
instance_var(nm, t, mt, id, p) => {
instance_var(/* FIXME (#2543) */ copy nm,
(self as ast_fold).fold_ty(t), mt, id, p)

2
src/libsyntax/parse.rs
View file

@ -189,7 +189,7 @@ fn new_parser_etc_from_file(sess: parse_sess, cfg: ast::crate_cfg,
+path: ~str, ftype: parser::file_type) ->
(parser, string_reader) {
let res = io::read_whole_file_str(path);
alt res {
match res {
result::ok(_) => { /* Continue. */ }
result::err(e) => sess.span_diagnostic.handler().fatal(e)
}

10
src/libsyntax/parse/attr.rs
View file

@ -29,7 +29,7 @@ impl parser_attr of parser_attr for parser {
-> attr_or_ext
{
let expect_item_next = vec::is_not_empty(first_item_attrs);
alt self.token {
match self.token {
token::POUND => {
let lo = self.span.lo;
if self.look_ahead(1u) == token::LBRACKET {
@ -57,7 +57,7 @@ impl parser_attr of parser_attr for parser {
fn parse_outer_attributes() -> ~[ast::attribute] {
let mut attrs: ~[ast::attribute] = ~[];
loop {
alt copy self.token {
match copy self.token {
token::POUND => {
if self.look_ahead(1u) != token::LBRACKET {
break;
@ -106,7 +106,7 @@ impl parser_attr of parser_attr for parser {
let mut inner_attrs: ~[ast::attribute] = ~[];
let mut next_outer_attrs: ~[ast::attribute] = ~[];
loop {
alt copy self.token {
match copy self.token {
token::POUND => {
if self.look_ahead(1u) != token::LBRACKET {
// This is an extension
@ -146,7 +146,7 @@ impl parser_attr of parser_attr for parser {
fn parse_meta_item() -> @ast::meta_item {
let lo = self.span.lo;
let ident = self.parse_ident();
alt self.token {
match self.token {
token::EQ => {
self.bump();
let lit = self.parse_lit();
@ -172,7 +172,7 @@ impl parser_attr of parser_attr for parser {
}
fn parse_optional_meta() -> ~[@ast::meta_item] {
alt self.token {
match self.token {
token::LPAREN => return self.parse_meta_seq(),
_ => return ~[]
}

14
src/libsyntax/parse/classify.rs
View file

@ -5,7 +5,7 @@
import ast_util::operator_prec;
fn expr_requires_semi_to_be_stmt(e: @ast::expr) -> bool {
alt e.node {
match e.node {
ast::expr_if(_, _, _) | ast::expr_alt(_, _, _) | ast::expr_block(_)
| ast::expr_while(_, _) | ast::expr_loop(_)
| ast::expr_call(_, _, true) => false,
@ -14,9 +14,9 @@ fn expr_requires_semi_to_be_stmt(e: @ast::expr) -> bool {
}
fn stmt_ends_with_semi(stmt: ast::stmt) -> bool {
alt stmt.node {
match stmt.node {
ast::stmt_decl(d, _) => {
return alt d.node {
return match d.node {
ast::decl_local(_) => true,
ast::decl_item(_) => false
}
@ -31,7 +31,7 @@ fn stmt_ends_with_semi(stmt: ast::stmt) -> bool {
}
fn need_parens(expr: @ast::expr, outer_prec: uint) -> bool {
alt expr.node {
match expr.node {
ast::expr_binary(op, _, _) => operator_prec(op) < outer_prec,
ast::expr_cast(_, _) => parse::prec::as_prec < outer_prec,
// This may be too conservative in some cases
@ -47,8 +47,8 @@ fn need_parens(expr: @ast::expr, outer_prec: uint) -> bool {
}
fn ends_in_lit_int(ex: @ast::expr) -> bool {
alt ex.node {
ast::expr_lit(node) => alt node {
match ex.node {
ast::expr_lit(node) => match node {
@{node: ast::lit_int(_, ast::ty_i), _}
| @{node: ast::lit_int_unsuffixed(_), _} => true,
_ => false
@ -60,7 +60,7 @@ fn ends_in_lit_int(ex: @ast::expr) -> bool {
ast::expr_log(_, _, sub) | ast::expr_assert(sub) => {
ends_in_lit_int(sub)
}
ast::expr_fail(osub) | ast::expr_ret(osub) => alt osub {
ast::expr_fail(osub) | ast::expr_ret(osub) => match osub {
some(ex) => ends_in_lit_int(ex),
_ => false
}

14
src/libsyntax/parse/common.rs
View file

@ -84,7 +84,7 @@ impl parser_common of parser_common for parser {
}
fn parse_ident() -> ast::ident {
alt copy self.token {
match copy self.token {
token::IDENT(i, _) => { self.bump(); return self.get_str(i); }
token::INTERPOLATED(token::nt_ident(*)) => { self.bug(
~"ident interpolation not converted to real token"); }
@ -118,7 +118,7 @@ impl parser_common of parser_common for parser {
}
fn token_is_word(word: ~str, ++tok: token::token) -> bool {
alt tok {
match tok {
token::IDENT(sid, false) => { word == *self.get_str(sid) }
_ => { false }
}
@ -134,7 +134,7 @@ impl parser_common of parser_common for parser {
}
fn is_any_keyword(tok: token::token) -> bool {
alt tok {
match tok {
token::IDENT(sid, false) => {
self.keywords.contains_key_ref(self.get_str(sid))
}
@ -146,7 +146,7 @@ impl parser_common of parser_common for parser {
self.require_keyword(word);
let mut bump = false;
let val = alt self.token {
let val = match self.token {
token::IDENT(sid, false) => {
if word == *self.get_str(sid) {
bump = true;
@ -173,7 +173,7 @@ impl parser_common of parser_common for parser {
}
fn check_restricted_keywords() {
alt self.token {
match self.token {
token::IDENT(_, false) => {
let w = token_to_str(self.reader, self.token);
self.check_restricted_keywords_(w);
@ -209,7 +209,7 @@ impl parser_common of parser_common for parser {
let mut v = ~[];
while self.token != token::GT
&& self.token != token::BINOP(token::SHR) {
alt sep {
match sep {
some(t) => {
if first { first = false; }
else { self.expect(t); }
@ -253,7 +253,7 @@ impl parser_common of parser_common for parser {
let mut first: bool = true;
let mut v: ~[T] = ~[];
while self.token != ket {
alt sep.sep {
match sep.sep {
some(t) => {
if first { first = false; }
else { self.expect(t); }

8
src/libsyntax/parse/eval.rs
View file

@ -47,7 +47,7 @@ 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<~str>) -> ~str {
return alt suffix {
return match suffix {
option::some(s) => path::connect(prefix, s),
option::none => prefix
} + ~".rs";
@ -56,7 +56,7 @@ fn parse_companion_mod(cx: ctx, prefix: ~str, suffix: option<~str>)
fn file_exists(path: ~str) -> bool {
// Crude, but there's no lib function for this and I'm not
// up to writing it just now
alt io::file_reader(path) {
match io::file_reader(path) {
result::ok(_) => true,
result::err(_) => false
}
@ -79,7 +79,7 @@ fn parse_companion_mod(cx: ctx, prefix: ~str, suffix: option<~str>)
}
fn cdir_path_opt(id: ast::ident, attrs: ~[ast::attribute]) -> @~str {
alt ::attr::first_attr_value_str_by_name(attrs, ~"path") {
match ::attr::first_attr_value_str_by_name(attrs, ~"path") {
some(d) => return d,
none => return id
}
@ -88,7 +88,7 @@ fn cdir_path_opt(id: ast::ident, attrs: ~[ast::attribute]) -> @~str {
fn eval_crate_directive(cx: ctx, cdir: @ast::crate_directive, prefix: ~str,
&view_items: ~[@ast::view_item],
&items: ~[@ast::item]) {
alt cdir.node {
match cdir.node {
ast::cdir_src_mod(id, attrs) => {
let file_path = cdir_path_opt(@(*id + ~".rs"), attrs);
let full_path =

24
src/libsyntax/parse/lexer.rs
View file

@ -206,7 +206,7 @@ fn consume_whitespace_and_comments(rdr: string_reader)
fn consume_any_line_comment(rdr: string_reader)
-> option<{tok: token::token, sp: span}> {
if rdr.curr == '/' {
alt nextch(rdr) {
match nextch(rdr) {
'/' => {
bump(rdr);
bump(rdr);
@ -313,7 +313,7 @@ fn scan_digits(rdr: string_reader, radix: uint) -> ~str {
loop {
let c = rdr.curr;
if c == '_' { bump(rdr); again; }
alt char::to_digit(c, radix) {
match char::to_digit(c, radix) {
some(d) => {
str::push_char(rslt, c);
bump(rdr);
@ -371,7 +371,7 @@ fn scan_number(c: char, rdr: string_reader) -> token::token {
rdr.fatal(~"no valid digits found for number");
}
let parsed = option::get(u64::from_str_radix(num_str, base as u64));
alt tp {
match tp {
either::left(t) => return token::LIT_INT(parsed as i64, t),
either::right(t) => return token::LIT_UINT(parsed, t)
}
@ -383,7 +383,7 @@ fn scan_number(c: char, rdr: string_reader) -> token::token {
let dec_part = scan_digits(rdr, 10u);
num_str += ~"." + dec_part;
}
alt scan_exponent(rdr) {
match scan_exponent(rdr) {
some(s) => {
is_float = true;
num_str += s;
@ -472,7 +472,7 @@ fn next_token_inner(rdr: string_reader) -> token::token {
return token::BINOPEQ(op);
} else { return token::BINOP(op); }
}
alt c {
match c {
@ -539,12 +539,12 @@ fn next_token_inner(rdr: string_reader) -> token::token {
}
'<' => {
bump(rdr);
alt rdr.curr {
match rdr.curr {
'=' => { bump(rdr); return token::LE; }
'<' => { return binop(rdr, token::SHL); }
'-' => {
bump(rdr);
alt rdr.curr {
match rdr.curr {
'>' => { bump(rdr); return token::DARROW; }
_ => { return token::LARROW; }
}
@ -554,7 +554,7 @@ fn next_token_inner(rdr: string_reader) -> token::token {
}
'>' => {
bump(rdr);
alt rdr.curr {
match rdr.curr {
'=' => { bump(rdr); return token::GE; }
'>' => { return binop(rdr, token::SHR); }
_ => { return token::GT; }
@ -567,7 +567,7 @@ fn next_token_inner(rdr: string_reader) -> token::token {
if c2 == '\\' {
let escaped = rdr.curr;
bump(rdr);
alt escaped {
match escaped {
'n' => { c2 = '\n'; }
'r' => { c2 = '\r'; }
't' => { c2 = '\t'; }
@ -599,11 +599,11 @@ fn next_token_inner(rdr: string_reader) -> token::token {
let ch = rdr.curr;
bump(rdr);
alt ch {
match ch {
'\\' => {
let escaped = rdr.curr;
bump(rdr);
alt escaped {
match escaped {
'n' => str::push_char(accum_str, '\n'),
'r' => str::push_char(accum_str, '\r'),
't' => str::push_char(accum_str, '\t'),
@ -646,7 +646,7 @@ fn next_token_inner(rdr: string_reader) -> token::token {
} else { return binop(rdr, token::AND); }
}
'|' => {
alt nextch(rdr) {
match nextch(rdr) {
'|' => { bump(rdr); bump(rdr); return token::OROR; }
_ => { return binop(rdr, token::OR); }
}

140
src/libsyntax/parse/parser.rs
View file

@ -107,7 +107,7 @@ type item_info = (ident, item_, option<~[attribute]>);
The important thing is to make sure that lookahead doesn't balk
at INTERPOLATED tokens */
macro_rules! maybe_whole_expr {
{$p:expr} => { alt copy $p.token {
{$p:expr} => { match copy $p.token {
INTERPOLATED(token::nt_expr(e)) => {
$p.bump();
return pexpr(e);
@ -122,19 +122,19 @@ macro_rules! maybe_whole_expr {
}
macro_rules! maybe_whole {
{$p:expr, $constructor:ident} => { alt copy $p.token {
{$p:expr, $constructor:ident} => { match copy $p.token {
INTERPOLATED(token::$constructor(x)) => { $p.bump(); return x; }
_ => ()
}} ;
{deref $p:expr, $constructor:ident} => { alt copy $p.token {
{deref $p:expr, $constructor:ident} => { match copy $p.token {
INTERPOLATED(token::$constructor(x)) => { $p.bump(); return *x; }
_ => ()
}} ;
{some $p:expr, $constructor:ident} => { alt copy $p.token {
{some $p:expr, $constructor:ident} => { match copy $p.token {
INTERPOLATED(token::$constructor(x)) => { $p.bump(); return some(x); }
_ => ()
}} ;
{pair_empty $p:expr, $constructor:ident} => { alt copy $p.token {
{pair_empty $p:expr, $constructor:ident} => { match copy $p.token {
INTERPOLATED(token::$constructor(x)) => { $p.bump(); return (~[], x); }
_ => ()
}}
@ -284,7 +284,7 @@ class parser {
debug!{"parse_trait_methods(): trait method signature ends in \
`%s`",
token_to_str(p.reader, p.token)};
alt p.token {
match p.token {
token::SEMI => {
p.bump();
debug!{"parse_trait_methods(): parsing required method"};
@ -356,7 +356,7 @@ class parser {
}
fn region_from_name(s: option<@~str>) -> @region {
let r = alt s {
let r = match s {
some (string) => re_named(string),
none => re_anon
};
@ -368,7 +368,7 @@ class parser {
fn parse_region() -> @region {
self.expect(token::BINOP(token::AND));
alt copy self.token {
match copy self.token {
token::IDENT(sid, _) => {
self.bump();
let n = self.get_str(sid);
@ -383,7 +383,7 @@ class parser {
// Parses something like "&x/" (note the trailing slash)
fn parse_region_with_sep() -> @region {
let name =
alt copy self.token {
match copy self.token {
token::IDENT(sid, _) => {
if self.look_ahead(1u) == token::BINOP(token::SLASH) {
self.bump(); self.bump();
@ -402,7 +402,7 @@ class parser {
let lo = self.span.lo;
alt self.maybe_parse_dollar_mac() {
match self.maybe_parse_dollar_mac() {
some(e) => {
return @{id: self.get_id(),
node: ty_mac(spanned(lo, self.span.hi, e)),
@ -471,7 +471,7 @@ class parser {
let sp = mk_sp(lo, self.last_span.hi);
return @{id: self.get_id(),
node: alt self.maybe_parse_fixed_vstore() {
node: match self.maybe_parse_fixed_vstore() {
// Consider a fixed vstore suffix (/N or /_)
none => t,
some(v) => {
@ -542,11 +542,11 @@ class parser {
}
fn maybe_parse_dollar_mac() -> option<mac_> {
alt copy self.token {
match copy self.token {
token::DOLLAR => {
let lo = self.span.lo;
self.bump();
alt copy self.token {
match copy self.token {
token::LIT_INT_UNSUFFIXED(num) => {
self.bump();
some(mac_var(num as uint))
@ -570,7 +570,7 @@ class parser {
fn maybe_parse_fixed_vstore() -> option<option<uint>> {
if self.token == token::BINOP(token::SLASH) {
self.bump();
alt copy self.token {
match copy self.token {
token::UNDERSCORE => {
self.bump(); some(none)
}
@ -585,7 +585,7 @@ class parser {
}
fn lit_from_token(tok: token::token) -> lit_ {
alt tok {
match tok {
token::LIT_INT(i, it) => lit_int(i, it),
token::LIT_UINT(u, ut) => lit_uint(u, ut),
token::LIT_INT_UNSUFFIXED(i) => lit_int_unsuffixed(i),
@ -733,7 +733,7 @@ class parser {
}
fn to_expr(e: pexpr) -> @expr {
alt e.node {
match e.node {
expr_tup(es) if vec::len(es) == 1u => es[0u],
_ => *e
}
@ -746,7 +746,7 @@ class parser {
let mut ex: expr_;
alt self.maybe_parse_dollar_mac() {
match self.maybe_parse_dollar_mac() {
some(x) => return pexpr(self.mk_mac_expr(lo, self.span.hi, x)),
_ => ()
}
@ -794,11 +794,11 @@ class parser {
return pexpr(self.parse_while_expr());
} else if self.eat_keyword(~"loop") {
return pexpr(self.parse_loop_expr());
} else if self.eat_keyword(~"alt") || self.eat_keyword(~"match") {
} else if self.eat_keyword(~"match") {
return pexpr(self.parse_alt_expr());
} else if self.eat_keyword(~"fn") {
let proto = self.parse_fn_ty_proto();
alt proto {
match proto {
proto_bare => self.fatal(~"fn expr are deprecated, use fn@"),
_ => { /* fallthrough */ }
}
@ -893,7 +893,7 @@ class parser {
/* `!`, as an operator, is prefix, so we know this isn't that */
if self.token == token::NOT {
self.bump();
let tts = alt self.token {
let tts = match self.token {
token::LPAREN | token::LBRACE | token::LBRACKET => {
let ket = token::flip_delimiter(self.token);
self.parse_unspanned_seq(copy self.token, ket,
@ -948,9 +948,9 @@ class parser {
// Vstore is legal following expr_lit(lit_str(...)) and expr_vec(...)
// only.
alt ex {
match ex {
expr_lit(@{node: lit_str(_), span: _}) |
expr_vec(_, _) => alt self.maybe_parse_fixed_vstore() {
expr_vec(_, _) => match self.maybe_parse_fixed_vstore() {
none => (),
some(v) => {
hi = self.span.hi;
@ -976,7 +976,7 @@ class parser {
}
fn parse_syntax_ext_naked(lo: uint) -> @expr {
alt self.token {
match self.token {
token::IDENT(_, _) => (),
_ => self.fatal(~"expected a syntax expander name")
}
@ -1003,7 +1003,7 @@ class parser {
let lo = self.span.lo;
let mut depth = 1u;
while (depth > 0u) {
alt (self.token) {
match (self.token) {
token::LBRACE => depth += 1u,
token::RBRACE => depth -= 1u,
token::EOF => self.fatal(~"unexpected EOF in macro body"),
@ -1033,7 +1033,7 @@ class parser {
loop {
// expr.f
if self.eat(token::DOT) {
alt copy self.token {
match copy self.token {
token::IDENT(i, _) => {
hi = self.span.hi;
self.bump();
@ -1051,7 +1051,7 @@ class parser {
again;
}
if self.expr_is_complete(e) { break; }
alt copy self.token {
match copy self.token {
// expr(...)
token::LPAREN if self.permits_call() => {
let es = self.parse_unspanned_seq(
@ -1103,7 +1103,7 @@ class parser {
maybe_whole!{deref self, nt_tt};
fn parse_tt_tok(p: parser, delim_ok: bool) -> token_tree {
alt p.token {
match p.token {
token::RPAREN | token::RBRACE | token::RBRACKET
if !delim_ok => {
p.fatal(~"incorrect close delimiter: `"
@ -1134,7 +1134,7 @@ class parser {
return res;
}
return alt self.token {
return match self.token {
token::LPAREN | token::LBRACE | token::LBRACKET => {
let ket = token::flip_delimiter(self.token);
tt_delim(vec::append(
@ -1154,7 +1154,7 @@ class parser {
// the interpolation of matchers
maybe_whole!{self, nt_matchers};
let name_idx = @mut 0u;
return alt self.token {
return match self.token {
token::LBRACE | token::LPAREN | token::LBRACKET => {
self.parse_matcher_subseq(name_idx, copy self.token,
token::flip_delimiter(self.token))
@ -1222,7 +1222,7 @@ class parser {
let mut hi;
let mut ex;
alt copy self.token {
match copy self.token {
token::NOT => {
self.bump();
let e = self.to_expr(self.parse_prefix_expr());
@ -1231,7 +1231,7 @@ class parser {
ex = expr_unary(not, e);
}
token::BINOP(b) => {
alt b {
match b {
token::MINUS => {
self.bump();
let e = self.to_expr(self.parse_prefix_expr());
@ -1251,7 +1251,7 @@ class parser {
let e = self.to_expr(self.parse_prefix_expr());
hi = e.span.hi;
// HACK: turn &[...] into a &-evec
ex = alt e.node {
ex = match e.node {
expr_vec(*) | expr_lit(@{node: lit_str(_), span: _})
if m == m_imm => {
expr_vstore(e, vstore_slice(self.region_from_name(none)))
@ -1268,7 +1268,7 @@ class parser {
let e = self.to_expr(self.parse_prefix_expr());
hi = e.span.hi;
// HACK: turn @[...] into a @-evec
ex = alt e.node {
ex = match e.node {
expr_vec(*) | expr_lit(@{node: lit_str(_), span: _})
if m == m_imm => expr_vstore(e, vstore_box),
_ => expr_unary(box(m), e)
@ -1280,7 +1280,7 @@ class parser {
let e = self.to_expr(self.parse_prefix_expr());
hi = e.span.hi;
// HACK: turn ~[...] into a ~-evec
ex = alt e.node {
ex = match e.node {
expr_vec(*) | expr_lit(@{node: lit_str(_), span: _})
if m == m_imm => expr_vstore(e, vstore_uniq),
_ => expr_unary(uniq(m), e)
@ -1311,7 +1311,7 @@ class parser {
return lhs;
}
let cur_opt = token_to_binop(peeked);
alt cur_opt {
match cur_opt {
some(cur_op) => {
let cur_prec = operator_prec(cur_op);
if cur_prec > min_prec {
@ -1338,7 +1338,7 @@ class parser {
fn parse_assign_expr() -> @expr {
let lo = self.span.lo;
let lhs = self.parse_binops();
alt copy self.token {
match copy self.token {
token::EQ => {
self.bump();
let rhs = self.parse_expr();
@ -1348,7 +1348,7 @@ class parser {
self.bump();
let rhs = self.parse_expr();
let mut aop;
alt op {
match op {
token::PLUS => aop = add,
token::MINUS => aop = subtract,
token::STAR => aop = mul,
@ -1412,7 +1412,7 @@ class parser {
fn parse_lambda_block_expr() -> @expr {
self.parse_lambda_expr_(
|| {
alt self.token {
match self.token {
token::BINOP(token::OR) | token::OROR => {
self.parse_fn_block_decl()
}
@ -1481,7 +1481,7 @@ class parser {
// Turn on the restriction to stop at | or || so we can parse
// them as the lambda arguments
let e = self.parse_expr_res(RESTRICT_NO_BAR_OR_DOUBLEBAR_OP);
alt e.node {
match e.node {
expr_call(f, args, false) => {
let block = self.parse_lambda_block_expr();
let last_arg = self.mk_expr(block.span.lo, block.span.hi,
@ -1608,7 +1608,7 @@ class parser {
}
fn parse_initializer() -> option<initializer> {
alt self.token {
match self.token {
token::EQ => {
self.bump();
return some({op: init_assign, expr: self.parse_expr()});
@ -1645,14 +1645,14 @@ class parser {
let lo = self.span.lo;
let mut hi = self.span.hi;
let mut pat;
alt self.token {
match self.token {
token::UNDERSCORE => { self.bump(); pat = pat_wild; }
token::AT => {
self.bump();
let sub = self.parse_pat(refutable);
hi = sub.span.hi;
// HACK: parse @"..." as a literal of a vstore @str
pat = alt sub.node {
pat = match sub.node {
pat_lit(e@@{
node: expr_lit(@{node: lit_str(_), span: _}), _
}) => {
@ -1669,7 +1669,7 @@ class parser {
let sub = self.parse_pat(refutable);
hi = sub.span.hi;
// HACK: parse ~"..." as a literal of a vstore ~str
pat = alt sub.node {
pat = match sub.node {
pat_lit(e@@{
node: expr_lit(@{node: lit_str(_), span: _}), _
}) => {
@ -1775,7 +1775,7 @@ class parser {
}
if is_plain_ident(self.token) &&
alt self.look_ahead(1) {
match self.look_ahead(1) {
token::LPAREN | token::LBRACKET | token::LT => {
false
}
@ -1794,8 +1794,8 @@ class parser {
hi = enum_path.span.hi;
let mut args: ~[@pat] = ~[];
let mut star_pat = false;
alt self.token {
token::LPAREN => alt self.look_ahead(1u) {
match self.token {
token::LPAREN => match self.look_ahead(1u) {
token::BINOP(token::STAR) => {
// This is a "top constructor only" pat
self.bump(); self.bump();
@ -1890,7 +1890,7 @@ class parser {
return @spanned(lo, decl.span.hi, stmt_decl(decl, self.get_id()));
} else {
let mut item_attrs;
alt self.parse_outer_attrs_or_ext(first_item_attrs) {
match self.parse_outer_attrs_or_ext(first_item_attrs) {
none => item_attrs = ~[],
some(left(attrs)) => item_attrs = attrs,
some(right(ext)) => {
@ -1901,7 +1901,7 @@ class parser {
let item_attrs = vec::append(first_item_attrs, item_attrs);
alt self.parse_item(item_attrs) {
match self.parse_item(item_attrs) {
some(i) => {
let mut hi = i.span.hi;
let decl = @spanned(lo, hi, decl_item(i));
@ -1993,16 +1993,16 @@ class parser {
}
while self.token != token::RBRACE {
alt self.token {
match self.token {
token::SEMI => {
self.bump(); // empty
}
_ => {
let stmt = self.parse_stmt(initial_attrs);
initial_attrs = ~[];
alt stmt.node {
match stmt.node {
stmt_expr(e, stmt_id) => { // Expression without semicolon:
alt self.token {
match self.token {
token::SEMI => {
self.bump();
push(stmts,
@ -2086,7 +2086,7 @@ class parser {
}
fn is_self_ident() -> bool {
alt self.token {
match self.token {
token::IDENT(sid, false) if ~"self" == *self.get_str(sid) => true,
_ => false
}
@ -2111,7 +2111,7 @@ class parser {
// backwards compatible.
let lo = self.span.lo;
let self_ty;
alt copy self.token {
match copy self.token {
token::BINOP(token::AND) => {
// We need to make sure it isn't a mode.
self.bump();
@ -2126,10 +2126,10 @@ class parser {
// Parse an explicit region, if possible.
let region_name;
alt copy self.token {
match copy self.token {
token::BINOP(token::SLASH) => {
self.bump();
alt copy self.token {
match copy self.token {
token::IDENT(sid, false) => {
self.bump();
region_name = some(self.get_str(sid));
@ -2174,7 +2174,7 @@ class parser {
// If we parsed a self type, expect a comma before the argument list.
let args_or_capture_items;
if self_ty != sty_by_ref {
alt copy self.token {
match copy self.token {
token::COMMA => {
self.bump();
let sep = seq_sep_trailing_disallowed(token::COMMA);
@ -2265,7 +2265,7 @@ class parser {
}
fn parse_method_name() -> ident {
alt copy self.token {
match copy self.token {
token::BINOP(op) => { self.bump(); @token::binop_to_str(op) }
token::NOT => { self.bump(); @~"!" }
token::LBRACKET => {
@ -2387,7 +2387,7 @@ class parser {
} else {
traits = ~[];
};
ident = alt ident_old {
ident = match ident_old {
some(name) => name,
none => { self.expect_keyword(~"of"); fail; }
};
@ -2445,7 +2445,7 @@ class parser {
codemap::span)> = none;
let mut the_dtor : option<(blk, ~[attribute], codemap::span)> = none;
while self.token != token::RBRACE {
alt self.parse_class_item(class_path) {
match self.parse_class_item(class_path) {
ctor_decl(a_fn_decl, attrs, blk, s) => {
the_ctor = some((a_fn_decl, attrs, blk, s));
}
@ -2463,7 +2463,7 @@ class parser {
body: d_body},
span: d_s}};
self.bump();
alt the_ctor {
match the_ctor {
some((ct_d, ct_attrs, ct_b, ct_s)) => {
(class_name,
item_class(ty_params, traits, ms, some({
@ -2487,7 +2487,7 @@ class parser {
}
fn token_is_pound_or_doc_comment(++tok: token::token) -> bool {
alt tok {
match tok {
token::POUND | token::DOC_COMMENT(_) => true,
_ => false
}
@ -2582,7 +2582,7 @@ class parser {
first = false;
}
debug!{"parse_mod_items: parse_item(attrs=%?)", attrs};
alt self.parse_item(attrs) {
match self.parse_item(attrs) {
some(i) => vec::push(items, i),
_ => {
self.fatal(~"expected item but found `" +
@ -2764,7 +2764,7 @@ class parser {
}
fn parse_fn_ty_proto() -> proto {
alt self.token {
match self.token {
token::AT => {
self.bump();
proto_box
@ -2784,7 +2784,7 @@ class parser {
}
fn fn_expr_lookahead(tok: token::token) -> bool {
alt tok {
match tok {
token::LPAREN | token::AT | token::TILDE | token::BINOP(_) => true,
_ => false
}
@ -2846,7 +2846,7 @@ class parser {
let pth = self.parse_path_without_tps();
self.expect(token::NOT);
let id = self.parse_ident();
let tts = alt self.token {
let tts = match self.token {
token::LPAREN | token::LBRACE | token::LBRACKET => {
let ket = token::flip_delimiter(self.token);
self.parse_unspanned_seq(copy self.token, ket,
@ -2863,7 +2863,7 @@ class parser {
(id, item_mac(m), none)
} else { return none; };
some(self.mk_item(lo, self.last_span.hi, ident, item_, visibility,
alt extra_attrs {
match extra_attrs {
some(as) => vec::append(attrs, as),
none => attrs
}))
@ -2880,7 +2880,7 @@ class parser {
let first_ident = self.parse_ident();
let mut path = ~[first_ident];
debug!{"parsed view_path: %s", *first_ident};
alt self.token {
match self.token {
token::EQ => {
// x = foo::bar
self.bump();
@ -2901,7 +2901,7 @@ class parser {
while self.token == token::MOD_SEP {
self.bump();
alt copy self.token {
match copy self.token {
token::IDENT(i, _) => {
self.bump();
@ -3004,7 +3004,7 @@ class parser {
}
fn parse_str() -> @~str {
alt copy self.token {
match copy self.token {
token::LIT_STR(s) => { self.bump(); self.get_str(s) }
_ => self.fatal(~"expected string literal")
}
@ -3035,7 +3035,7 @@ class parser {
self.expect_keyword(~"module");
}
let id = self.parse_ident();
alt self.token {
match self.token {
// mod x = "foo.rs";
token::SEMI => {
let mut hi = self.span.hi;

2
src/libsyntax/parse/prec.rs
View file

@ -20,7 +20,7 @@ const as_prec: uint = 11u;
* operator and its precedence
*/
fn token_to_binop(tok: token) -> option<ast::binop> {
alt tok {
match tok {
BINOP(STAR) => some(mul),
BINOP(SLASH) => some(div),
BINOP(PERCENT) => some(rem),

22
src/libsyntax/parse/token.rs
View file

@ -102,7 +102,7 @@ enum nonterminal {
}
fn binop_to_str(o: binop) -> ~str {
alt o {
match o {
PLUS => ~"+",
MINUS => ~"-",
STAR => ~"*",
@ -117,7 +117,7 @@ fn binop_to_str(o: binop) -> ~str {
}
fn to_str(in: interner<@~str>, t: token) -> ~str {
alt t {
match t {
EQ => ~"=",
LT => ~"<",
LE => ~"<=",
@ -186,7 +186,7 @@ fn to_str(in: interner<@~str>, t: token) -> ~str {
EOF => ~"<eof>",
INTERPOLATED(nt) => {
~"an interpolated " +
alt nt {
match nt {
nt_item(*) => ~"item",
nt_block(*) => ~"block",
nt_stmt(*) => ~"statement",
@ -203,7 +203,7 @@ fn to_str(in: interner<@~str>, t: token) -> ~str {
}
pure fn can_begin_expr(t: token) -> bool {
alt t {
match t {
LPAREN => true,
LBRACE => true,
LBRACKET => true,
@ -234,7 +234,7 @@ pure fn can_begin_expr(t: token) -> bool {
/// what's the opposite delimiter?
fn flip_delimiter(&t: token::token) -> token::token {
alt t {
match t {
token::LPAREN => token::RPAREN,
token::LBRACE => token::RBRACE,
token::LBRACKET => token::RBRACKET,
@ -248,7 +248,7 @@ fn flip_delimiter(&t: token::token) -> token::token {
fn is_lit(t: token) -> bool {
alt t {
match t {
LIT_INT(_, _) => true,
LIT_UINT(_, _) => true,
LIT_INT_UNSUFFIXED(_) => true,
@ -259,22 +259,22 @@ fn is_lit(t: token) -> bool {
}
pure fn is_ident(t: token) -> bool {
alt t { IDENT(_, _) => true, _ => false }
match t { IDENT(_, _) => true, _ => false }
}
pure fn is_ident_or_path(t: token) -> bool {
alt t {
match t {
IDENT(_, _) | INTERPOLATED(nt_path(*)) => true,
_ => false
}
}
pure fn is_plain_ident(t: token) -> bool {
alt t { IDENT(_, false) => true, _ => false }
match t { IDENT(_, false) => true, _ => false }
}
pure fn is_bar(t: token) -> bool {
alt t { BINOP(OR) | OROR => true, _ => false }
match t { BINOP(OR) | OROR => true, _ => false }
}
/**
@ -333,7 +333,7 @@ fn contextual_keyword_table() -> hashmap<~str, ()> {
fn restricted_keyword_table() -> hashmap<~str, ()> {
let words = str_hash();
let keys = ~[
~"alt", ~"again", ~"assert",
~"again", ~"assert",
~"break",
~"check", ~"class", ~"const", ~"copy",
~"do", ~"drop",

12
src/libsyntax/print/pp.rs
View file

@ -62,7 +62,7 @@ type begin_t = {offset: int, breaks: breaks};
enum token { STRING(@~str, int), BREAK(break_t), BEGIN(begin_t), END, EOF, }
fn tok_str(++t: token) -> ~str {
alt t {
match t {
STRING(s, len) => return fmt!{"STR(%s,%d)", *s, len},
BREAK(_) => return ~"BREAK",
BEGIN(_) => return ~"BEGIN",
@ -238,7 +238,7 @@ impl printer for printer {
fn replace_last_token(t: token) { self.token[self.right] = t; }
fn pretty_print(t: token) {
debug!{"pp ~[%u,%u]", self.left, self.right};
alt t {
match t {
EOF => {
if !self.scan_stack_empty {
self.check_stack(0);
@ -357,7 +357,7 @@ impl printer for printer {
self.left, L};
if L >= 0 {
self.print(x, L);
alt x {
match x {
BREAK(b) => self.left_total += b.blank_space,
STRING(_, len) => { assert (len == L); self.left_total += len; }
_ => ()
@ -373,7 +373,7 @@ impl printer for printer {
fn check_stack(k: int) {
if !self.scan_stack_empty {
let x = self.scan_top();
alt copy self.token[x] {
match copy self.token[x] {
BEGIN(b) => {
if k > 0 {
self.size[self.scan_pop()] = self.size[x] +
@ -422,7 +422,7 @@ impl printer for printer {
debug!{"print %s %d (remaining line space=%d)", tok_str(x), L,
self.space};
log(debug, buf_str(self.token, self.size, self.left, self.right, 6u));
alt x {
match x {
BEGIN(b) => {
if L > self.space {
let col = self.margin - self.space + b.offset;
@ -442,7 +442,7 @@ impl printer for printer {
}
BREAK(b) => {
let top = self.get_top();
alt top.pbreak {
match top.pbreak {
fits => {
debug!{"print BREAK in fitting block"};
self.space -= b.blank_space;

152
src/libsyntax/print/pprust.rs
View file

@ -222,11 +222,11 @@ fn bclose_(s: ps, span: codemap::span, indented: uint) {
fn bclose(s: ps, span: codemap::span) { bclose_(s, span, indent_unit); }
fn is_begin(s: ps) -> bool {
alt s.s.last_token() { pp::BEGIN(_) => true, _ => false }
match s.s.last_token() { pp::BEGIN(_) => true, _ => false }
}
fn is_end(s: ps) -> bool {
alt s.s.last_token() { pp::END => true, _ => false }
match s.s.last_token() { pp::END => true, _ => false }
}
fn is_bol(s: ps) -> bool {
@ -318,7 +318,7 @@ fn print_foreign_mod(s: ps, nmod: ast::foreign_mod,
}
fn print_region(s: ps, region: @ast::region) {
alt region.node {
match region.node {
ast::re_anon => word_space(s, ~"&"),
ast::re_named(name) => {
word(s.s, ~"&");
@ -334,14 +334,14 @@ fn print_type(s: ps, &&ty: @ast::ty) {
fn print_type_ex(s: ps, &&ty: @ast::ty, print_colons: bool) {
maybe_print_comment(s, ty.span.lo);
ibox(s, 0u);
alt ty.node {
match ty.node {
ast::ty_nil => word(s.s, ~"()"),
ast::ty_bot => word(s.s, ~"!"),
ast::ty_box(mt) => { word(s.s, ~"@"); print_mt(s, mt); }
ast::ty_uniq(mt) => { word(s.s, ~"~"); print_mt(s, mt); }
ast::ty_vec(mt) => {
word(s.s, ~"[");
alt mt.mutbl {
match mt.mutbl {
ast::m_mutbl => word_space(s, ~"mut"),
ast::m_const => word_space(s, ~"const"),
ast::m_imm => ()
@ -351,7 +351,7 @@ fn print_type_ex(s: ps, &&ty: @ast::ty, print_colons: bool) {
}
ast::ty_ptr(mt) => { word(s.s, ~"*"); print_mt(s, mt); }
ast::ty_rptr(region, mt) => {
alt region.node {
match region.node {
ast::re_anon => word(s.s, ~"&"),
_ => { print_region(s, region); word(s.s, ~"/"); }
}
@ -400,7 +400,7 @@ fn print_foreign_item(s: ps, item: @ast::foreign_item) {
hardbreak_if_not_bol(s);
maybe_print_comment(s, item.span.lo);
print_outer_attributes(s, item.attrs);
alt item.node {
match item.node {
ast::foreign_item_fn(decl, typarams) => {
print_fn(s, decl, item.ident, typarams);
end(s); // end head-ibox
@ -416,7 +416,7 @@ fn print_item(s: ps, &&item: @ast::item) {
print_outer_attributes(s, item.attrs);
let ann_node = node_item(s, item);
s.ann.pre(ann_node);
alt item.node {
match item.node {
ast::item_const(ty, expr) => {
head(s, ~"const");
word_space(s, *item.ident + ~":");
@ -538,7 +538,7 @@ fn print_item(s: ps, &&item: @ast::item) {
hardbreak_if_not_bol(s);
maybe_print_comment(s, ci.span.lo);
let pr = ast_util::class_member_visibility(ci);
alt pr {
match pr {
ast::private => {
head(s, ~"priv");
bopen(s);
@ -546,10 +546,10 @@ fn print_item(s: ps, &&item: @ast::item) {
}
_ => ()
}
alt ci.node {
match ci.node {
ast::instance_var(nm, t, mt, _,_) => {
word_nbsp(s, ~"let");
alt mt {
match mt {
ast::class_mutable => word_nbsp(s, ~"mut"),
_ => ()
}
@ -562,7 +562,7 @@ fn print_item(s: ps, &&item: @ast::item) {
print_method(s, m);
}
}
alt pr {
match pr {
ast::private => bclose(s, ci.span),
_ => ()
}
@ -625,10 +625,10 @@ fn print_item(s: ps, &&item: @ast::item) {
/// and then pretty-print the resulting AST nodes (so, e.g., we print
/// expression arguments as expressions). It can be done! I think.
fn print_tt(s: ps, tt: ast::token_tree) {
alt tt {
match tt {
ast::tt_delim(tts) => for tts.each() |tt_elt| { print_tt(s, tt_elt); }
ast::tt_tok(_, tk) => {
alt tk {
match tk {
parse::token::IDENT(*) => { // don't let idents run together
if s.s.token_tree_last_was_ident { word(s.s, ~" ") }
s.s.token_tree_last_was_ident = true;
@ -641,7 +641,7 @@ fn print_tt(s: ps, tt: ast::token_tree) {
word(s.s, ~"$(");
for tts.each() |tt_elt| { print_tt(s, tt_elt); }
word(s.s, ~")");
alt sep {
match sep {
some(tk) => word(s.s, parse::token::to_str(*s.intr, tk)),
none => ()
}
@ -665,7 +665,7 @@ fn print_variant(s: ps, v: ast::variant) {
commasep(s, consistent, v.node.args, print_variant_arg);
pclose(s);
}
alt v.node.disr_expr {
match v.node.disr_expr {
some(d) => {
space(s.s);
word_space(s, ~"=");
@ -684,7 +684,7 @@ fn print_ty_method(s: ps, m: ast::ty_method) {
}
fn print_trait_method(s: ps, m: ast::trait_method) {
alt m {
match m {
required(ty_m) => print_ty_method(s, ty_m),
provided(m) => print_method(s, m)
}
@ -702,7 +702,7 @@ fn print_method(s: ps, meth: @ast::method) {
fn print_outer_attributes(s: ps, attrs: ~[ast::attribute]) {
let mut count = 0;
for attrs.each |attr| {
alt attr.node.style {
match attr.node.style {
ast::attr_outer => { print_attribute(s, attr); count += 1; }
_ => {/* fallthrough */ }
}
@ -713,7 +713,7 @@ fn print_outer_attributes(s: ps, attrs: ~[ast::attribute]) {
fn print_inner_attributes(s: ps, attrs: ~[ast::attribute]) {
let mut count = 0;
for attrs.each |attr| {
alt attr.node.style {
match attr.node.style {
ast::attr_inner => {
print_attribute(s, attr);
if !attr.node.is_sugared_doc {
@ -744,7 +744,7 @@ fn print_attribute(s: ps, attr: ast::attribute) {
fn print_stmt(s: ps, st: ast::stmt) {
maybe_print_comment(s, st.span.lo);
alt st.node {
match st.node {
ast::stmt_decl(decl, _) => {
print_decl(s, decl);
}
@ -780,7 +780,7 @@ fn print_possibly_embedded_block(s: ps, blk: ast::blk, embedded: embed_type,
fn print_possibly_embedded_block_(s: ps, blk: ast::blk, embedded: embed_type,
indented: uint, attrs: ~[ast::attribute]) {
alt blk.node.rules {
match blk.node.rules {
ast::unchecked_blk => word(s.s, ~"unchecked"),
ast::unsafe_blk => word(s.s, ~"unsafe"),
ast::default_blk => ()
@ -788,7 +788,7 @@ fn print_possibly_embedded_block_(s: ps, blk: ast::blk, embedded: embed_type,
maybe_print_comment(s, blk.span.lo);
let ann_node = node_block(s, blk);
s.ann.pre(ann_node);
alt embedded {
match embedded {
block_block_fn => end(s),
block_normal => bopen(s)
}
@ -799,7 +799,7 @@ fn print_possibly_embedded_block_(s: ps, blk: ast::blk, embedded: embed_type,
for blk.node.stmts.each |st| {
print_stmt(s, *st);
}
alt blk.node.expr {
match blk.node.expr {
some(expr) => {
space_if_not_bol(s);
print_expr(s, expr);
@ -814,7 +814,7 @@ fn print_possibly_embedded_block_(s: ps, blk: ast::blk, embedded: embed_type,
// return and fail, without arguments cannot appear is the discriminant of if,
// alt, do, & while unambiguously without being parenthesized
fn print_maybe_parens_discrim(s: ps, e: @ast::expr) {
let disambig = alt e.node {
let disambig = match e.node {
ast::expr_ret(none) | ast::expr_fail(none) => true,
_ => false
};
@ -831,9 +831,9 @@ fn print_if(s: ps, test: @ast::expr, blk: ast::blk,
space(s.s);
print_block(s, blk);
fn do_else(s: ps, els: option<@ast::expr>) {
alt els {
match els {
some(_else) => {
alt _else.node {
match _else.node {
// "another else-if"
ast::expr_if(i, t, e) => {
cbox(s, indent_unit - 1u);
@ -864,11 +864,11 @@ fn print_if(s: ps, test: @ast::expr, blk: ast::blk,
}
fn print_mac(s: ps, m: ast::mac) {
alt m.node {
match m.node {
ast::mac_invoc(path, arg, body) => {
word(s.s, ~"#");
print_path(s, path, false);
alt arg {
match arg {
some(@{node: ast::expr_vec(_, _), _}) => (),
_ => word(s.s, ~" ")
}
@ -888,12 +888,12 @@ fn print_mac(s: ps, m: ast::mac) {
}
fn print_vstore(s: ps, t: ast::vstore) {
alt t {
match t {
ast::vstore_fixed(some(i)) => word(s.s, fmt!{"%u", i}),
ast::vstore_fixed(none) => word(s.s, ~"_"),
ast::vstore_uniq => word(s.s, ~"~"),
ast::vstore_box => word(s.s, ~"@"),
ast::vstore_slice(r) => alt r.node {
ast::vstore_slice(r) => match r.node {
ast::re_anon => word(s.s, ~"&"),
ast::re_named(name) => {
word(s.s, ~"&");
@ -919,8 +919,8 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
ibox(s, indent_unit);
let ann_node = node_expr(s, expr);
s.ann.pre(ann_node);
alt expr.node {
ast::expr_vstore(e, v) => alt v {
match expr.node {
ast::expr_vstore(e, v) => match v {
ast::vstore_fixed(_) => {
print_expr(s, e);
word(s.s, ~"/");
@ -961,7 +961,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
ast::expr_rec(fields, wth) => {
word(s.s, ~"{");
commasep_cmnt(s, consistent, fields, print_field, get_span);
alt wth {
match wth {
some(expr) => {
if vec::len(fields) > 0u { space(s.s); }
ibox(s, indent_unit);
@ -977,7 +977,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
print_path(s, path, true);
word(s.s, ~"{");
commasep_cmnt(s, consistent, fields, print_field, get_span);
alt wth {
match wth {
some(expr) => {
if vec::len(fields) > 0u { space(s.s); }
ibox(s, indent_unit);
@ -998,7 +998,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
let mut base_args = args;
let blk = if has_block {
let blk_arg = vec::pop(base_args);
alt blk_arg.node {
match blk_arg.node {
ast::expr_loop_body(_) => word_nbsp(s, ~"for"),
ast::expr_do_body(_) => word_nbsp(s, ~"do"),
_ => ()
@ -1056,7 +1056,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
ast::expr_alt(expr, arms, mode) => {
cbox(s, alt_indent_unit);
ibox(s, 4u);
word_nbsp(s, ~"alt");
word_nbsp(s, ~"match");
if mode == ast::alt_check { word_nbsp(s, ~"check"); }
print_maybe_parens_discrim(s, expr);
space(s.s);
@ -1074,7 +1074,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
print_pat(s, p);
}
space(s.s);
alt arm.guard {
match arm.guard {
some(e) => {
word_space(s, ~"if");
print_expr(s, e);
@ -1087,7 +1087,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
assert arm.body.node.view_items.is_empty();
assert arm.body.node.stmts.is_empty();
assert arm.body.node.rules == ast::default_blk;
alt arm.body.node.expr {
match arm.body.node.expr {
some(expr) => {
end(s); // close the ibox for the pattern
print_expr(s, expr);
@ -1185,7 +1185,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
ast::expr_path(path) => print_path(s, path, true),
ast::expr_fail(maybe_fail_val) => {
word(s.s, ~"fail");
alt maybe_fail_val {
match maybe_fail_val {
some(expr) => { word(s.s, ~" "); print_expr(s, expr); }
_ => ()
}
@ -1194,13 +1194,13 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
ast::expr_again => word(s.s, ~"again"),
ast::expr_ret(result) => {
word(s.s, ~"return");
alt result {
match result {
some(expr) => { word(s.s, ~" "); print_expr(s, expr); }
_ => ()
}
}
ast::expr_log(lvl, lexp, expr) => {
alt check lvl {
match check lvl {
1 => { word_nbsp(s, ~"log"); print_expr(s, expr); }
0 => { word_nbsp(s, ~"log_err"); print_expr(s, expr); }
2 => {
@ -1225,7 +1225,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
}
fn print_expr_parens_if_not_bot(s: ps, ex: @ast::expr) {
let parens = alt ex.node {
let parens = match ex.node {
ast::expr_fail(_) | ast::expr_ret(_) |
ast::expr_binary(_, _, _) | ast::expr_unary(_, _) |
ast::expr_move(_, _) | ast::expr_copy(_) |
@ -1243,7 +1243,7 @@ fn print_expr_parens_if_not_bot(s: ps, ex: @ast::expr) {
fn print_local_decl(s: ps, loc: @ast::local) {
print_pat(s, loc.node.pat);
alt loc.node.ty.node {
match loc.node.ty.node {
ast::ty_infer => (),
_ => { word_space(s, ~":"); print_type(s, loc.node.ty); }
}
@ -1251,7 +1251,7 @@ fn print_local_decl(s: ps, loc: @ast::local) {
fn print_decl(s: ps, decl: @ast::decl) {
maybe_print_comment(s, decl.span.lo);
alt decl.node {
match decl.node {
ast::decl_local(locs) => {
space_if_not_bol(s);
ibox(s, indent_unit);
@ -1267,10 +1267,10 @@ fn print_decl(s: ps, decl: @ast::decl) {
ibox(s, indent_unit);
print_local_decl(s, loc);
end(s);
alt loc.node.init {
match loc.node.init {
some(init) => {
nbsp(s);
alt init.op {
match init.op {
ast::init_assign => word_space(s, ~"="),
ast::init_move => word_space(s, ~"<-")
}
@ -1306,7 +1306,7 @@ fn print_path(s: ps, &&path: @ast::path, colons_before_params: bool) {
if path.rp.is_some() || !path.types.is_empty() {
if colons_before_params { word(s.s, ~"::"); }
alt path.rp {
match path.rp {
none => { /* ok */ }
some(r) => {
word(s.s, ~"/");
@ -1328,22 +1328,22 @@ fn print_pat(s: ps, &&pat: @ast::pat) {
s.ann.pre(ann_node);
/* Pat isn't normalized, but the beauty of it
is that it doesn't matter */
alt pat.node {
match pat.node {
ast::pat_wild => word(s.s, ~"_"),
ast::pat_ident(binding_mode, path, sub) => {
alt binding_mode {
match binding_mode {
ast::bind_by_ref => word_space(s, ~"ref"),
ast::bind_by_value => ()
}
print_path(s, path, true);
alt sub {
match sub {
some(p) => { word(s.s, ~"@"); print_pat(s, p); }
none => ()
}
}
ast::pat_enum(path, args_) => {
print_path(s, path, true);
alt args_ {
match args_ {
none => word(s.s, ~"(*)"),
some(args) => {
if vec::len(args) > 0u {
@ -1391,7 +1391,7 @@ fn print_pat(s: ps, &&pat: @ast::pat) {
fn print_fn(s: ps, decl: ast::fn_decl, name: ast::ident,
typarams: ~[ast::ty_param]) {
alt decl.purity {
match decl.purity {
ast::impure_fn => head(s, ~"fn"),
_ => head(s, purity_to_str(decl.purity) + ~" fn")
}
@ -1442,7 +1442,7 @@ fn print_fn_block_args(s: ps, decl: ast::fn_decl,
}
fn mode_to_str(m: ast::mode) -> ~str {
alt m {
match m {
ast::expl(ast::by_mutbl_ref) => ~"&",
ast::expl(ast::by_move) => ~"-",
ast::expl(ast::by_ref) => ~"&&",
@ -1462,7 +1462,7 @@ fn print_bounds(s: ps, bounds: @~[ast::ty_param_bound]) {
word(s.s, ~":");
for vec::each(*bounds) |bound| {
nbsp(s);
alt bound {
match bound {
ast::bound_copy => word(s.s, ~"copy"),
ast::bound_send => word(s.s, ~"send"),
ast::bound_const => word(s.s, ~"const"),
@ -1487,7 +1487,7 @@ fn print_type_params(s: ps, &&params: ~[ast::ty_param]) {
fn print_meta_item(s: ps, &&item: @ast::meta_item) {
ibox(s, indent_unit);
alt item.node {
match item.node {
ast::meta_word(name) => word(s.s, *name),
ast::meta_name_value(name, value) => {
word_space(s, *name);
@ -1505,7 +1505,7 @@ fn print_meta_item(s: ps, &&item: @ast::meta_item) {
}
fn print_view_path(s: ps, &&vp: @ast::view_path) {
alt vp.node {
match vp.node {
ast::view_path_simple(ident, path, _) => {
if path.idents[vec::len(path.idents)-1u] != ident {
word_space(s, *ident);
@ -1538,7 +1538,7 @@ fn print_view_item(s: ps, item: @ast::view_item) {
hardbreak_if_not_bol(s);
maybe_print_comment(s, item.span.lo);
print_outer_attributes(s, item.attrs);
alt item.node {
match item.node {
ast::view_item_use(id, mta, _) => {
head(s, ~"use");
word(s.s, *id);
@ -1572,7 +1572,7 @@ fn print_op_maybe_parens(s: ps, expr: @ast::expr, outer_prec: uint) {
}
fn print_mutability(s: ps, mutbl: ast::mutability) {
alt mutbl {
match mutbl {
ast::m_mutbl => word_nbsp(s, ~"mut"),
ast::m_const => word_nbsp(s, ~"const"),
ast::m_imm => {/* nothing */ }
@ -1587,7 +1587,7 @@ fn print_mt(s: ps, mt: ast::mt) {
fn print_arg(s: ps, input: ast::arg) {
ibox(s, indent_unit);
print_arg_mode(s, input.mode);
alt input.ty.node {
match input.ty.node {
ast::ty_infer => word(s.s, *input.ident),
_ => {
if str::len(*input.ident) > 0u {
@ -1604,8 +1604,8 @@ fn print_ty_fn(s: ps, opt_proto: option<ast::proto>,
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); } _ => () }
alt tps { some(tps) => print_type_params(s, tps), _ => () }
match id { some(id) => { word(s.s, ~" "); word(s.s, *id); } _ => () }
match tps { some(tps) => print_type_params(s, tps), _ => () }
zerobreak(s.s);
popen(s);
commasep(s, inconsistent, decl.inputs, print_arg);
@ -1625,14 +1625,14 @@ fn print_ty_fn(s: ps, opt_proto: option<ast::proto>,
fn maybe_print_trailing_comment(s: ps, span: codemap::span,
next_pos: option<uint>) {
let mut cm;
alt s.cm { some(ccm) => cm = ccm, _ => return }
alt next_comment(s) {
match s.cm { some(ccm) => cm = ccm, _ => return }
match next_comment(s) {
some(cmnt) => {
if cmnt.style != comments::trailing { return; }
let span_line = codemap::lookup_char_pos(cm, span.hi);
let comment_line = codemap::lookup_char_pos(cm, cmnt.pos);
let mut next = cmnt.pos + 1u;
alt next_pos { none => (), some(p) => next = p }
match next_pos { none => (), some(p) => next = p }
if span.hi < cmnt.pos && cmnt.pos < next &&
span_line.line == comment_line.line {
print_comment(s, cmnt);
@ -1648,7 +1648,7 @@ fn print_remaining_comments(s: ps) {
// make sure there is a line break at the end.
if option::is_none(next_comment(s)) { hardbreak(s.s); }
loop {
alt next_comment(s) {
match next_comment(s) {
some(cmnt) => { print_comment(s, cmnt); s.cur_cmnt += 1u; }
_ => break
}
@ -1657,14 +1657,14 @@ fn print_remaining_comments(s: ps) {
fn print_literal(s: ps, &&lit: @ast::lit) {
maybe_print_comment(s, lit.span.lo);
alt next_lit(s, lit.span.lo) {
match next_lit(s, lit.span.lo) {
some(ltrl) => {
word(s.s, ltrl.lit);
return;
}
_ => ()
}
alt lit.node {
match lit.node {
ast::lit_str(st) => print_string(s, *st),
ast::lit_int(ch, ast::ty_char) => {
word(s.s, ~"'" + char::escape_default(ch as char) + ~"'");
@ -1705,7 +1705,7 @@ fn print_literal(s: ps, &&lit: @ast::lit) {
fn lit_to_str(l: @ast::lit) -> ~str { return to_str(l, print_literal); }
fn next_lit(s: ps, pos: uint) -> option<comments::lit> {
alt s.literals {
match s.literals {
some(lits) => {
while s.cur_lit < vec::len(lits) {
let ltrl = lits[s.cur_lit];
@ -1721,7 +1721,7 @@ fn next_lit(s: ps, pos: uint) -> option<comments::lit> {
fn maybe_print_comment(s: ps, pos: uint) {
loop {
alt next_comment(s) {
match next_comment(s) {
some(cmnt) => {
if cmnt.pos < pos {
print_comment(s, cmnt);
@ -1734,7 +1734,7 @@ fn maybe_print_comment(s: ps, pos: uint) {
}
fn print_comment(s: ps, cmnt: comments::cmnt) {
alt cmnt.style {
match cmnt.style {
comments::mixed => {
assert (vec::len(cmnt.lines) == 1u);
zerobreak(s.s);
@ -1767,7 +1767,7 @@ fn print_comment(s: ps, cmnt: comments::cmnt) {
comments::blank_line => {
// We need to do at least one, possibly two hardbreaks.
let is_semi =
alt s.s.last_token() {
match s.s.last_token() {
pp::STRING(s, _) => *s == ~";",
_ => false
};
@ -1792,7 +1792,7 @@ fn to_str<T>(t: T, f: fn@(ps, T)) -> ~str {
}
fn next_comment(s: ps) -> option<comments::cmnt> {
alt s.comments {
match s.comments {
some(cmnts) => {
if s.cur_cmnt < vec::len(cmnts) {
return some(cmnts[s.cur_cmnt]);
@ -1803,14 +1803,14 @@ fn next_comment(s: ps) -> option<comments::cmnt> {
}
fn opt_proto_to_str(opt_p: option<ast::proto>) -> ~str {
alt opt_p {
match opt_p {
none => ~"fn",
some(p) => proto_to_str(p)
}
}
pure fn purity_to_str(p: ast::purity) -> ~str {
alt p {
match p {
ast::impure_fn => ~"impure",
ast::unsafe_fn => ~"unsafe",
ast::pure_fn => ~"pure",
@ -1819,14 +1819,14 @@ pure fn purity_to_str(p: ast::purity) -> ~str {
}
fn print_purity(s: ps, p: ast::purity) {
alt p {
match p {
ast::impure_fn => (),
_ => word_nbsp(s, purity_to_str(p))
}
}
fn proto_to_str(p: ast::proto) -> ~str {
return alt p {
return match p {
ast::proto_bare => ~"extern fn",
ast::proto_block => ~"fn&",
ast::proto_uniq => ~"fn~",

2
src/libsyntax/util/interner.rs
View file

@ -27,7 +27,7 @@ trait interner<T: const copy> {
impl <T: const copy> of interner<T> for hash_interner<T> {
fn intern(val: T) -> uint {
alt self.map.find(val) {
match self.map.find(val) {
some(idx) => return idx,
none => {
let new_idx = self.vect.len();

32
src/libsyntax/visit.rs
View file

@ -25,7 +25,7 @@ enum fn_kind {
}
fn name_of_fn(fk: fn_kind) -> ident {
alt fk {
match fk {
fk_item_fn(name, _) | fk_method(name, _, _)
| fk_ctor(name, _, _, _, _) => /* FIXME (#2543) */ copy name,
fk_anon(*) | fk_fn_block(*) => @~"anon",
@ -34,7 +34,7 @@ fn name_of_fn(fk: fn_kind) -> ident {
}
fn tps_of_fn(fk: fn_kind) -> ~[ty_param] {
alt fk {
match fk {
fk_item_fn(_, tps) | fk_method(_, tps, _)
| fk_ctor(_, _, tps, _, _) | fk_dtor(tps, _, _, _) => {
/* FIXME (#2543) */ copy tps
@ -89,7 +89,7 @@ fn visit_crate<E>(c: crate, e: E, v: vt<E>) {
}
fn visit_crate_directive<E>(cd: @crate_directive, e: E, v: vt<E>) {
alt cd.node {
match cd.node {
cdir_src_mod(_, _) => (),
cdir_dir_mod(_, cdirs, _) => for cdirs.each |cdir| {
visit_crate_directive(cdir, e, v);
@ -109,14 +109,14 @@ fn visit_view_item<E>(_vi: @view_item, _e: E, _v: vt<E>) { }
fn visit_local<E>(loc: @local, e: E, v: vt<E>) {
v.visit_pat(loc.node.pat, e, v);
v.visit_ty(loc.node.ty, e, v);
alt loc.node.init {
match loc.node.init {
none => (),
some(i) => v.visit_expr(i.expr, e, v)
}
}
fn visit_item<E>(i: @item, e: E, v: vt<E>) {
alt i.node {
match i.node {
item_const(t, ex) => { v.visit_ty(t, e, v); v.visit_expr(ex, e, v); }
item_fn(decl, tp, body) => {
v.visit_fn(fk_item_fn(/* FIXME (#2543) */ copy i.ident,
@ -175,7 +175,7 @@ fn visit_item<E>(i: @item, e: E, v: vt<E>) {
}
fn visit_class_item<E>(cm: @class_member, e:E, v:vt<E>) {
alt cm.node {
match cm.node {
instance_var(_, t, _, _, _) => v.visit_ty(t, e, v),
class_method(m) => visit_method_helper(m, e, v)
}
@ -184,7 +184,7 @@ fn visit_class_item<E>(cm: @class_member, e:E, v:vt<E>) {
fn skip_ty<E>(_t: @ty, _e: E, _v: vt<E>) {}
fn visit_ty<E>(t: @ty, e: E, v: vt<E>) {
alt t.node {
match t.node {
ty_box(mt) | ty_uniq(mt) |
ty_vec(mt) | ty_ptr(mt) | ty_rptr(_, mt) => {
v.visit_ty(mt.ty, e, v);
@ -213,7 +213,7 @@ fn visit_path<E>(p: @path, e: E, v: vt<E>) {
}
fn visit_pat<E>(p: @pat, e: E, v: vt<E>) {
alt p.node {
match p.node {
pat_enum(path, children) => {
visit_path(path, e, v);
do option::iter(children) |children| {
@ -237,7 +237,7 @@ fn visit_pat<E>(p: @pat, e: E, v: vt<E>) {
}
fn visit_foreign_item<E>(ni: @foreign_item, e: E, v: vt<E>) {
alt ni.node {
match ni.node {
foreign_item_fn(fd, tps) => {
v.visit_ty_params(tps, e, v);
visit_fn_decl(fd, e, v);
@ -248,7 +248,7 @@ fn visit_foreign_item<E>(ni: @foreign_item, e: E, v: vt<E>) {
fn visit_ty_params<E>(tps: ~[ty_param], e: E, v: vt<E>) {
for tps.each |tp| {
for vec::each(*tp.bounds) |bound| {
alt bound {
match bound {
bound_trait(t) => v.visit_ty(t, e, v),
bound_copy | bound_send | bound_const | bound_owned => ()
}
@ -304,7 +304,7 @@ fn visit_ty_method<E>(m: ty_method, e: E, v: vt<E>) {
}
fn visit_trait_method<E>(m: trait_method, e: E, v: vt<E>) {
alt m {
match m {
required(ty_m) => v.visit_ty_method(ty_m, e, v),
provided(m) => visit_method_helper(m, e, v)
}
@ -317,7 +317,7 @@ fn visit_block<E>(b: ast::blk, e: E, v: vt<E>) {
}
fn visit_stmt<E>(s: @stmt, e: E, v: vt<E>) {
alt s.node {
match s.node {
stmt_decl(d, _) => v.visit_decl(d, e, v),
stmt_expr(ex, _) => v.visit_expr(ex, e, v),
stmt_semi(ex, _) => v.visit_expr(ex, e, v)
@ -325,7 +325,7 @@ fn visit_stmt<E>(s: @stmt, e: E, v: vt<E>) {
}
fn visit_decl<E>(d: @decl, e: E, v: vt<E>) {
alt d.node {
match d.node {
decl_local(locs) => for locs.each |loc| {
v.visit_local(loc, e, v)
}
@ -334,7 +334,7 @@ fn visit_decl<E>(d: @decl, 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) }
match eo { none => (), some(ex) => v.visit_expr(ex, e, v) }
}
fn visit_exprs<E>(exprs: ~[@expr], e: E, v: vt<E>) {
@ -342,7 +342,7 @@ fn visit_exprs<E>(exprs: ~[@expr], e: E, v: vt<E>) {
}
fn visit_mac<E>(m: mac, e: E, v: vt<E>) {
alt m.node {
match m.node {
ast::mac_invoc(pth, arg, body) => {
option::map(arg, |arg| v.visit_expr(arg, e, v)); }
ast::mac_invoc_tt(pth, tt) => { /* no user-serviceable parts inside */ }
@ -353,7 +353,7 @@ fn visit_mac<E>(m: mac, e: E, v: vt<E>) {
}
fn visit_expr<E>(ex: @expr, e: E, v: vt<E>) {
alt ex.node {
match ex.node {
expr_vstore(x, _) => v.visit_expr(x, e, v),
expr_vec(es, _) => visit_exprs(es, e, v),
expr_repeat(element, count, _) => {

24
src/rustc/back/link.rs
View file

@ -61,7 +61,7 @@ mod write {
// and the extension to use.
fn mk_intermediate_name(output_path: ~str, extension: ~str) ->
~str unsafe {
let stem = alt str::find_char(output_path, '.') {
let stem = match str::find_char(output_path, '.') {
some(dot_pos) => str::slice(output_path, 0u, dot_pos),
none => output_path
};
@ -82,7 +82,7 @@ mod write {
// specified.
if opts.save_temps {
alt opts.output_type {
match opts.output_type {
output_type_bitcode => {
if opts.optimize != 0u {
let filename = mk_intermediate_name(output, ~"no-opt.bc");
@ -146,7 +146,7 @@ mod write {
let LLVMOptDefault = 2 as c_int; // -O2, -Os
let LLVMOptAggressive = 3 as c_int; // -O3
let mut CodeGenOptLevel = alt check opts.optimize {
let mut CodeGenOptLevel = match check opts.optimize {
0u => LLVMOptNone,
1u => LLVMOptLess,
2u => LLVMOptDefault,
@ -323,12 +323,12 @@ fn build_link_meta(sess: session, c: ast::crate, output: ~str,
attr::require_unique_names(sess.diagnostic(), linkage_metas);
for linkage_metas.each |meta| {
if *attr::get_meta_item_name(meta) == ~"name" {
alt attr::get_meta_item_value_str(meta) {
match attr::get_meta_item_value_str(meta) {
some(v) => { name = some(v); }
none => vec::push(cmh_items, meta)
}
} else if *attr::get_meta_item_name(meta) == ~"vers" {
alt attr::get_meta_item_value_str(meta) {
match attr::get_meta_item_value_str(meta) {
some(v) => { vers = some(v); }
none => vec::push(cmh_items, meta)
}
@ -355,7 +355,7 @@ fn build_link_meta(sess: session, c: ast::crate, output: ~str,
symbol_hasher.reset();
for cmh_items.each |m_| {
let m = m_;
alt m.node {
match m.node {
ast::meta_name_value(key, value) => {
symbol_hasher.write_str(len_and_str(*key));
symbol_hasher.write_str(len_and_str_lit(value));
@ -385,7 +385,7 @@ fn build_link_meta(sess: session, c: ast::crate, output: ~str,
fn crate_meta_name(sess: session, _crate: ast::crate,
output: ~str, metas: provided_metas) -> @~str {
return alt metas.name {
return match metas.name {
some(v) => v,
none => {
let name =
@ -407,7 +407,7 @@ fn build_link_meta(sess: session, c: ast::crate, output: ~str,
fn crate_meta_vers(sess: session, _crate: ast::crate,
metas: provided_metas) -> @~str {
return alt metas.vers {
return match metas.vers {
some(v) => v,
none => {
let vers = ~"0.0";
@ -451,7 +451,7 @@ fn symbol_hash(tcx: ty::ctxt, symbol_hasher: &hash::State, t: ty::t,
}
fn get_symbol_hash(ccx: @crate_ctxt, t: ty::t) -> ~str {
alt ccx.type_hashcodes.find(t) {
match ccx.type_hashcodes.find(t) {
some(h) => return h,
none => {
let hash = symbol_hash(ccx.tcx, ccx.symbol_hasher, t, ccx.link_meta);
@ -467,7 +467,7 @@ fn get_symbol_hash(ccx: @crate_ctxt, t: ty::t) -> ~str {
fn sanitize(s: ~str) -> ~str {
let mut result = ~"";
do str::chars_iter(s) |c| {
alt c {
match c {
'@' => result += ~"_sbox_",
'~' => result += ~"_ubox_",
'*' => result += ~"_ptr_",
@ -503,7 +503,7 @@ fn mangle(ss: path) -> ~str {
let mut n = ~"_ZN"; // Begin name-sequence.
for ss.each |s| {
alt s { path_name(s) | path_mod(s) => {
match s { path_name(s) | path_mod(s) => {
let sani = sanitize(*s);
n += fmt!{"%u%s", str::len(sani), sani};
} }
@ -566,7 +566,7 @@ fn link_binary(sess: session,
vec::pop(parts);
return str::connect(parts, ~".");
}
return alt config.os {
return match config.os {
session::os_macos => rmext(rmlib(filename)),
session::os_linux => rmext(rmlib(filename)),
session::os_freebsd => rmext(rmlib(filename)),

4
src/rustc/back/rpath.rs
View file

@ -7,7 +7,7 @@ import metadata::filesearch;
export get_rpath_flags;
pure fn not_win32(os: session::os) -> bool {
alt os {
match os {
session::os_win32 => false,
_ => true
}
@ -108,7 +108,7 @@ fn get_rpath_relative_to_output(os: session::os,
assert not_win32(os);
// Mac doesn't appear to support $ORIGIN
let prefix = alt os {
let prefix = match os {
session::os_linux => ~"$ORIGIN" + path::path_sep(),
session::os_freebsd => ~"$ORIGIN" + path::path_sep(),
session::os_macos => ~"@executable_path" + path::path_sep(),

4
src/rustc/back/x86.rs
View file

@ -8,7 +8,7 @@ fn get_target_strs(target_os: session::os) -> target_strs::t {
meta_sect_name: meta_section_name(sess_os_to_meta_os(target_os)),
data_layout: alt target_os {
data_layout: match target_os {
session::os_macos => {
~"e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16" +
~"-i32:32:32-i64:32:64" +
@ -29,7 +29,7 @@ fn get_target_strs(target_os: session::os) -> target_strs::t {
}
},
target_triple: alt target_os {
target_triple: match target_os {
session::os_macos => ~"i686-apple-darwin",
session::os_win32 => ~"i686-pc-mingw32",
session::os_linux => ~"i686-unknown-linux-gnu",

4
src/rustc/back/x86_64.rs
View file

@ -8,7 +8,7 @@ fn get_target_strs(target_os: session::os) -> target_strs::t {
meta_sect_name: meta_section_name(sess_os_to_meta_os(target_os)),
data_layout: alt target_os {
data_layout: match target_os {
session::os_macos => {
~"e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"+
~"f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-"+
@ -35,7 +35,7 @@ fn get_target_strs(target_os: session::os) -> target_strs::t {
}
},
target_triple: alt target_os {
target_triple: match target_os {
session::os_macos => ~"x86_64-apple-darwin",
session::os_win32 => ~"x86_64-pc-mingw32",
session::os_linux => ~"x86_64-unknown-linux-gnu",

50
src/rustc/driver/driver.rs
View file

@ -26,7 +26,7 @@ enum pp_mode {ppm_normal, ppm_expanded, ppm_typed, ppm_identified,
fn anon_src() -> ~str { ~"<anon>" }
fn source_name(input: input) -> ~str {
alt input {
match input {
file_input(ifile) => ifile,
str_input(_) => anon_src()
}
@ -34,7 +34,7 @@ fn source_name(input: input) -> ~str {
fn default_configuration(sess: session, argv0: ~str, input: input) ->
ast::crate_cfg {
let libc = alt sess.targ_cfg.os {
let libc = match sess.targ_cfg.os {
session::os_win32 => ~"msvcrt.dll",
session::os_macos => ~"libc.dylib",
session::os_linux => ~"libc.so.6",
@ -44,7 +44,7 @@ fn default_configuration(sess: session, argv0: ~str, input: input) ->
let mk = attr::mk_name_value_item_str;
let (arch,wordsz) = alt sess.targ_cfg.arch {
let (arch,wordsz) = match sess.targ_cfg.arch {
session::arch_x86 => (~"x86",~"32"),
session::arch_x86_64 => (~"x86_64",~"64"),
session::arch_arm => (~"arm",~"32")
@ -99,7 +99,7 @@ enum input {
fn parse_input(sess: session, cfg: ast::crate_cfg, input: input)
-> @ast::crate {
alt input {
match input {
file_input(file) => {
parse::parse_crate_from_file(file, cfg, sess.parse_sess)
}
@ -270,13 +270,13 @@ fn compile_input(sess: session, cfg: ast::crate_cfg, input: input,
fn pretty_print_input(sess: session, cfg: ast::crate_cfg, input: input,
ppm: pp_mode) {
fn ann_paren_for_expr(node: pprust::ann_node) {
alt node {
match node {
pprust::node_expr(s, expr) => pprust::popen(s),
_ => ()
}
}
fn ann_typed_post(tcx: ty::ctxt, node: pprust::ann_node) {
alt node {
match node {
pprust::node_expr(s, expr) => {
pp::space(s.s);
pp::word(s.s, ~"as");
@ -288,7 +288,7 @@ fn pretty_print_input(sess: session, cfg: ast::crate_cfg, input: input,
}
}
fn ann_identified_post(node: pprust::ann_node) {
alt node {
match node {
pprust::node_item(s, item) => {
pp::space(s.s);
pprust::synth_comment(s, int::to_str(item.id, 10u));
@ -314,14 +314,14 @@ fn pretty_print_input(sess: session, cfg: ast::crate_cfg, input: input,
// to collect comments and literals, and we need to support reading
// from stdin, we're going to just suck the source into a string
// so both the parser and pretty-printer can use it.
let upto = alt ppm {
let upto = match ppm {
ppm_expanded | ppm_expanded_identified => cu_expand,
ppm_typed => cu_typeck,
_ => cu_parse
};
let {crate, tcx} = compile_upto(sess, cfg, input, upto, none);
let ann = alt ppm {
let ann = match ppm {
ppm_typed => {
{pre: ann_paren_for_expr,
post: |a| ann_typed_post(option::get(tcx), a) }
@ -371,21 +371,21 @@ fn get_arch(triple: ~str) -> option<session::arch> {
fn build_target_config(sopts: @session::options,
demitter: diagnostic::emitter) -> @session::config {
let os = alt get_os(sopts.target_triple) {
let os = match get_os(sopts.target_triple) {
some(os) => os,
none => early_error(demitter, ~"unknown operating system")
};
let arch = alt get_arch(sopts.target_triple) {
let arch = match get_arch(sopts.target_triple) {
some(arch) => arch,
none => early_error(demitter,
~"unknown architecture: " + sopts.target_triple)
};
let (int_type, uint_type, float_type) = alt arch {
let (int_type, uint_type, float_type) = match arch {
session::arch_x86 => (ast::ty_i32, ast::ty_u32, ast::ty_f64),
session::arch_x86_64 => (ast::ty_i64, ast::ty_u64, ast::ty_f64),
session::arch_arm => (ast::ty_i32, ast::ty_u32, ast::ty_f64)
};
let target_strs = alt arch {
let target_strs = match arch {
session::arch_x86 => x86::get_target_strs(os),
session::arch_x86_64 => x86_64::get_target_strs(os),
session::arch_arm => x86::get_target_strs(os)
@ -438,7 +438,7 @@ fn build_session_options(matches: getopts::matches,
getopts::opt_strs(matches, level_name));
for flags.each |lint_name| {
let lint_name = str::replace(lint_name, ~"-", ~"_");
alt lint_dict.find(lint_name) {
match lint_dict.find(lint_name) {
none => {
early_error(demitter, fmt!{"unknown %s flag: %s",
level_name, lint_name});
@ -486,7 +486,7 @@ fn build_session_options(matches: getopts::matches,
let sysroot_opt = getopts::opt_maybe_str(matches, ~"sysroot");
let target_opt = getopts::opt_maybe_str(matches, ~"target");
let save_temps = getopts::opt_present(matches, ~"save-temps");
alt output_type {
match output_type {
// unless we're emitting huamn-readable assembly, omit comments.
link::output_type_llvm_assembly | link::output_type_assembly => (),
_ => debugging_opts |= session::no_asm_comments
@ -498,7 +498,7 @@ fn build_session_options(matches: getopts::matches,
}
2u
} else if opt_present(matches, ~"opt-level") {
alt getopts::opt_str(matches, ~"opt-level") {
match getopts::opt_str(matches, ~"opt-level") {
~"0" => 0u,
~"1" => 1u,
~"2" => 2u,
@ -510,7 +510,7 @@ fn build_session_options(matches: getopts::matches,
}
} else { 0u };
let target =
alt target_opt {
match target_opt {
none => host_triple(),
some(s) => s
};
@ -577,7 +577,7 @@ fn build_session_(sopts: @session::options,
}
fn parse_pretty(sess: session, &&name: ~str) -> pp_mode {
alt name {
match name {
~"normal" => ppm_normal,
~"expanded" => ppm_expanded,
~"typed" => ppm_typed,
@ -628,7 +628,7 @@ fn build_output_filenames(input: input,
let obj_suffix =
alt sopts.output_type {
match sopts.output_type {
link::output_type_none => ~"none",
link::output_type_bitcode => ~"bc",
link::output_type_assembly => ~"s",
@ -637,20 +637,20 @@ fn build_output_filenames(input: input,
link::output_type_object | link::output_type_exe => ~"o"
};
alt ofile {
match ofile {
none => {
// "-" as input file will cause the parser to read from stdin so we
// have to make up a name
// We want to toss everything after the final '.'
let dirname = alt odir {
let dirname = match odir {
some(d) => d,
none => alt input {
none => match input {
str_input(_) => os::getcwd(),
file_input(ifile) => path::dirname(ifile)
}
};
let base_filename = alt input {
let base_filename = match input {
file_input(ifile) => {
let (path, _) = path::splitext(ifile);
path::basename(path)
@ -714,7 +714,7 @@ mod test {
#[test]
fn test_switch_implies_cfg_test() {
let matches =
alt getopts::getopts(~[~"--test"], opts()) {
match getopts::getopts(~[~"--test"], opts()) {
ok(m) => m,
err(f) => fail ~"test_switch_implies_cfg_test: " +
getopts::fail_str(f)
@ -730,7 +730,7 @@ mod test {
#[test]
fn test_switch_implies_cfg_test_unless_cfg_test() {
let matches =
alt getopts::getopts(~[~"--test", ~"--cfg=test"], opts()) {
match getopts::getopts(~[~"--test", ~"--cfg=test"], opts()) {
ok(m) => m,
err(f) => {
fail ~"test_switch_implies_cfg_test_unless_cfg_test: " +

Some files were not shown because too many files have changed in this diff Show more