Convert ret to return

src/libsyntax/codemap.rs

@@ -58,7 +58,7 @@ fn new_filemap_w_substr(+filename: filename, +substr: file_substr,
                         src: @~str,
                         start_pos_ch: uint, start_pos_byte: uint)
    -> filemap {
-    ret @{name: filename, substr: substr, src: src,
+    return @{name: filename, substr: substr, src: src,
           start_pos: {ch: start_pos_ch, byte: start_pos_byte},
           mut lines: ~[{ch: start_pos_ch, byte: start_pos_byte}]};
 }
@@ -66,14 +66,14 @@ fn new_filemap_w_substr(+filename: filename, +substr: file_substr,
 fn new_filemap(+filename: filename, src: @~str,
                start_pos_ch: uint, start_pos_byte: uint)
     -> filemap {
-    ret new_filemap_w_substr(filename, fss_none, src,
+    return new_filemap_w_substr(filename, fss_none, src,
                              start_pos_ch, start_pos_byte);
 }
 
 fn mk_substr_filename(cm: codemap, sp: span) -> ~str
 {
     let pos = lookup_char_pos(cm, sp.lo);
-    ret fmt!{"<%s:%u:%u>", pos.file.name, pos.line, pos.col};
+    return fmt!{"<%s:%u:%u>", pos.file.name, pos.line, pos.col};
 }
 
 fn next_line(file: filemap, chpos: uint, byte_pos: uint) {
@@ -102,22 +102,22 @@ fn lookup_line(map: codemap, pos: uint, lookup: lookup_fn)
         let m = (a + b) / 2u;
         if lookup(f.lines[m]) > pos { b = m; } else { a = m; }
     }
-    ret {fm: f, line: a};
+    return {fm: f, line: a};
 }
 
 fn lookup_pos(map: codemap, pos: uint, lookup: lookup_fn) -> loc {
     let {fm: f, line: a} = lookup_line(map, pos, lookup);
-    ret {file: f, line: a + 1u, col: pos - lookup(f.lines[a])};
+    return {file: f, line: a + 1u, col: pos - lookup(f.lines[a])};
 }
 
 fn lookup_char_pos(map: codemap, pos: uint) -> loc {
-    pure fn lookup(pos: file_pos) -> uint { ret pos.ch; }
-    ret lookup_pos(map, pos, lookup);
+    pure fn lookup(pos: file_pos) -> uint { return pos.ch; }
+    return lookup_pos(map, pos, lookup);
 }
 
 fn lookup_byte_pos(map: codemap, pos: uint) -> loc {
-    pure fn lookup(pos: file_pos) -> uint { ret pos.byte; }
-    ret lookup_pos(map, pos, lookup);
+    pure fn lookup(pos: file_pos) -> uint { return pos.byte; }
+    return lookup_pos(map, pos, lookup);
 }
 
 fn lookup_char_pos_adj(map: codemap, pos: uint)
@@ -144,7 +144,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 { ret pos.ch; }
+    pure fn lookup(pos: file_pos) -> uint { return pos.ch; }
     let line = lookup_line(map, sp.lo, lookup);
     alt (line.fm.substr) {
       fss_none {sp}
@@ -166,14 +166,14 @@ type span = {lo: uint, hi: uint, expn_info: expn_info};
 fn span_to_str_no_adj(sp: span, cm: codemap) -> ~str {
     let lo = lookup_char_pos(cm, sp.lo);
     let hi = lookup_char_pos(cm, sp.hi);
-    ret fmt!{"%s:%u:%u: %u:%u", lo.file.name,
+    return fmt!{"%s:%u:%u: %u:%u", lo.file.name,
              lo.line, lo.col, hi.line, hi.col}
 }
 
 fn span_to_str(sp: span, cm: codemap) -> ~str {
     let lo = lookup_char_pos_adj(cm, sp.lo);
     let hi = lookup_char_pos_adj(cm, sp.hi);
-    ret fmt!{"%s:%u:%u: %u:%u", lo.filename,
+    return fmt!{"%s:%u:%u: %u:%u", lo.filename,
              lo.line, lo.col, hi.line, hi.col}
 }
 
@@ -181,7 +181,7 @@ type file_lines = {file: filemap, lines: ~[uint]};
 
 fn span_to_filename(sp: span, cm: codemap::codemap) -> filename {
     let lo = lookup_char_pos(cm, sp.lo);
-    ret /* FIXME (#2543) */ copy lo.file.name;
+    return /* FIXME (#2543) */ copy lo.file.name;
 }
 
 fn span_to_lines(sp: span, cm: codemap::codemap) -> @file_lines {
@@ -191,7 +191,7 @@ fn span_to_lines(sp: span, cm: codemap::codemap) -> @file_lines {
     for uint::range(lo.line - 1u, hi.line as uint) |i| {
         vec::push(lines, i);
     };
-    ret @{file: lo.file, lines: lines};
+    return @{file: lo.file, lines: lines};
 }
 
 fn get_line(fm: filemap, line: int) -> ~str unsafe {
@@ -205,7 +205,7 @@ fn get_line(fm: filemap, line: int) -> ~str unsafe {
 
 fn lookup_byte_offset(cm: codemap::codemap, chpos: uint)
     -> {fm: filemap, pos: uint} {
-    pure fn lookup(pos: file_pos) -> uint { ret pos.ch; }
+    pure fn lookup(pos: file_pos) -> uint { return pos.ch; }
     let {fm, line} = lookup_line(cm, chpos, lookup);
     let line_offset = fm.lines[line].byte - fm.start_pos.byte;
     let col = chpos - fm.lines[line].ch;
@@ -217,17 +217,17 @@ fn span_to_snippet(sp: span, cm: codemap::codemap) -> ~str {
     let begin = lookup_byte_offset(cm, sp.lo);
     let end = lookup_byte_offset(cm, sp.hi);
     assert begin.fm == end.fm;
-    ret str::slice(*begin.fm.src, begin.pos, end.pos);
+    return str::slice(*begin.fm.src, begin.pos, end.pos);
 }
 
 fn get_snippet(cm: codemap::codemap, fidx: uint, lo: uint, hi: uint) -> ~str
 {
     let fm = cm.files[fidx];
-    ret str::slice(*fm.src, lo, hi)
+    return str::slice(*fm.src, lo, hi)
 }
 
 fn get_filemap(cm: codemap, filename: ~str) -> filemap {
-    for cm.files.each |fm| { if fm.name == filename { ret fm; } }
+    for cm.files.each |fm| { if fm.name == filename { return fm; } }
     //XXjdm the following triggers a mismatched type bug
     //      (or expected function, found _|_)
     fail; // ("asking for " + filename + " which we don't know about");