---

yaml
---
r: 36347
b: refs/heads/try2
c: 1a1e99c
h: refs/heads/master
i:
  36345: 5481733
  36343: 466d33a
v: v3

Author: brson

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: eb8fd119c65c67f3b1b8268cc7341c22d39b7b61
 refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 401093ec7d66f898338abb30b8097e06bfeb1a58
+refs/heads/try2: 1a1e99c27d0d701f315926f400aa325ddfc8a9e7
 refs/heads/incoming: d9317a174e434d4c99fc1a37fd7dc0d2f5328d37
 refs/heads/dist-snap: 22efa39382d41b084fde1719df7ae8ce5697d8c9
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try2/src/libcore/char.rs

@@ -126,19 +126,16 @@ pub pure fn to_digit(c: char, radix: uint) -> Option<uint> {
  *   - chars in [0x100,0xffff] get 4-digit escapes: `\\uNNNN`
  *   - chars above 0x10000 get 8-digit escapes: `\\UNNNNNNNN`
  */
-pub pure fn escape_unicode(c: char) -> ~str {
+pub fn escape_unicode(c: char) -> ~str {
     let s = u32::to_str(c as u32, 16u);
     let (c, pad) = (if c <= '\xff' { ('x', 2u) }
                     else if c <= '\uffff' { ('u', 4u) }
                     else { ('U', 8u) });
     assert str::len(s) <= pad;
     let mut out = ~"\\";
-    unsafe {
-        str::push_str(&mut out, str::from_char(c));
-        for uint::range(str::len(s), pad) |_i|
-            { str::push_str(&mut out, ~"0"); }
-        str::push_str(&mut out, s);
-    }
+    str::push_str(&mut out, str::from_char(c));
+    for uint::range(str::len(s), pad) |_i| { str::push_str(&mut out, ~"0"); }
+    str::push_str(&mut out, s);
     move out
 }
 
@@ -154,7 +151,7 @@ pub pure fn escape_unicode(c: char) -> ~str {
  *   - Any other chars in the range [0x20,0x7e] are not escaped.
  *   - Any other chars are given hex unicode escapes; see `escape_unicode`.
  */
-pub pure fn escape_default(c: char) -> ~str {
+pub fn escape_default(c: char) -> ~str {
     match c {
       '\t' => ~"\\t",
       '\r' => ~"\\r",

branches/try2/src/libcore/from_str.rs

@@ -7,6 +7,6 @@
 use option::Option;
 
 pub trait FromStr {
-    static pure fn from_str(s: &str) -> Option<self>;
+    static fn from_str(s: &str) -> Option<self>;
 }
 

branches/try2/src/libcore/int-template.rs

@@ -106,7 +106,7 @@ impl T: iter::Times {
  * * buf - A byte buffer
  * * radix - The base of the number
  */
-pub pure fn parse_bytes(buf: &[u8], radix: uint) -> Option<T> {
+pub fn parse_bytes(buf: &[u8], radix: uint) -> Option<T> {
     if vec::len(buf) == 0u { return None; }
     let mut i = vec::len(buf) - 1u;
     let mut start = 0u;
@@ -129,13 +129,10 @@ pub pure fn parse_bytes(buf: &[u8], radix: uint) -> Option<T> {
 }
 
 /// Parse a string to an int
-pub pure fn from_str(s: &str) -> Option<T>
-{
-    parse_bytes(str::to_bytes(s), 10u)
-}
+pub fn from_str(s: &str) -> Option<T> { parse_bytes(str::to_bytes(s), 10u) }
 
 impl T : FromStr {
-    static pure fn from_str(s: &str) -> Option<T> { from_str(s) }
+    static fn from_str(s: &str) -> Option<T> { from_str(s) }
 }
 
 /// Convert to a string in a given base

branches/try2/src/libcore/io.rs

@@ -512,7 +512,7 @@ pub pure fn with_bytes_reader<t>(bytes: &[u8], f: fn(Reader) -> t) -> t {
     f(BytesReader { bytes: bytes, pos: 0u } as Reader)
 }
 
-pub pure fn with_str_reader<T>(s: &str, f: fn(Reader) -> T) -> T {
+pub fn with_str_reader<T>(s: &str, f: fn(Reader) -> T) -> T {
     str::byte_slice(s, |bytes| with_bytes_reader(bytes, f))
 }
 

branches/try2/src/libcore/mutable.rs

@@ -48,7 +48,7 @@ impl<T> Data<T> {
         }
     }
 
-    pure fn borrow_const<R>(op: &fn(t: &const T) -> R) -> R {
+    fn borrow_const<R>(op: &fn(t: &const T) -> R) -> R {
         op(&const self.value)
     }
 

branches/try2/src/libcore/result.rs

@@ -204,13 +204,13 @@ pub fn map_err<T: Copy, E, F: Copy>(res: &Result<T, E>, op: fn((&E)) -> F)
 }
 
 impl<T, E> Result<T, E> {
-    pure fn get_ref(&self) -> &self/T { get_ref(self) }
+    fn get_ref(&self) -> &self/T { get_ref(self) }
 
-    pure fn is_ok() -> bool { is_ok(&self) }
+    fn is_ok() -> bool { is_ok(&self) }
 
-    pure fn is_err() -> bool { is_err(&self) }
+    fn is_err() -> bool { is_err(&self) }
 
-    pure fn iter(f: fn((&T))) {
+    fn iter(f: fn((&T))) {
         match self {
           Ok(ref t) => f(t),
           Err(_) => ()
@@ -226,7 +226,7 @@ impl<T, E> Result<T, E> {
 }
 
 impl<T: Copy, E> Result<T, E> {
-    pure fn get() -> T { get(&self) }
+    fn get() -> T { get(&self) }
 
     fn map_err<F:Copy>(op: fn((&E)) -> F) -> Result<T,F> {
         match self {
@@ -237,7 +237,7 @@ impl<T: Copy, E> Result<T, E> {
 }
 
 impl<T, E: Copy> Result<T, E> {
-    pure fn get_err() -> E { get_err(&self) }
+    fn get_err() -> E { get_err(&self) }
 
     fn map<U:Copy>(op: fn((&T)) -> U) -> Result<U,E> {
         match self {

branches/try2/src/libcore/uint-template.rs

@@ -100,7 +100,7 @@ impl T: iter::Times {
  *
  * `buf` must not be empty
  */
-pub pure fn parse_bytes(buf: &[const u8], radix: uint) -> Option<T> {
+pub fn parse_bytes(buf: &[const u8], radix: uint) -> Option<T> {
     if vec::len(buf) == 0u { return None; }
     let mut i = vec::len(buf) - 1u;
     let mut power = 1u as T;
@@ -117,13 +117,10 @@ pub pure fn parse_bytes(buf: &[const u8], radix: uint) -> Option<T> {
 }
 
 /// Parse a string to an int
-pub pure fn from_str(s: &str) -> Option<T>
-{
-    parse_bytes(str::to_bytes(s), 10u)
-}
+pub fn from_str(s: &str) -> Option<T> { parse_bytes(str::to_bytes(s), 10u) }
 
 impl T : FromStr {
-    static pure fn from_str(s: &str) -> Option<T> { from_str(s) }
+    static fn from_str(s: &str) -> Option<T> { from_str(s) }
 }
 
 /// Parse a string as an unsigned integer.

branches/try2/src/libfuzzer/fuzzer.rs

@@ -225,7 +225,7 @@ fn as_str(f: fn@(+x: io::Writer)) -> ~str {
     io::with_str_writer(f)
 }
 
-fn check_variants_of_ast(crate: ast::crate, codemap: codemap::CodeMap,
+fn check_variants_of_ast(crate: ast::crate, codemap: @codemap::CodeMap,
                          filename: &Path, cx: context) {
     let stolen = steal(crate, cx.mode);
     let extra_exprs = vec::filter(common_exprs(),
@@ -239,7 +239,7 @@ fn check_variants_of_ast(crate: ast::crate, codemap: codemap::CodeMap,
 
 fn check_variants_T<T: Copy>(
   crate: ast::crate,
-  codemap: codemap::CodeMap,
+  codemap: @codemap::CodeMap,
   filename: &Path,
   thing_label: ~str,
   things: ~[T],

branches/try2/src/librustc/driver/driver.rs

@@ -366,7 +366,7 @@ fn pretty_print_input(sess: Session, cfg: ast::crate_cfg, input: input,
       ppm_expanded | ppm_normal => pprust::no_ann()
     };
     let is_expanded = upto != cu_parse;
-    let src = codemap::get_filemap(sess.codemap, source_name(input)).src;
+    let src = sess.codemap.get_filemap(source_name(input)).src;
     do io::with_str_reader(*src) |rdr| {
         pprust::print_crate(sess.codemap, sess.parse_sess.interner,
                             sess.span_diagnostic, crate,
@@ -586,7 +586,7 @@ fn build_session_options(binary: ~str,
 
 fn build_session(sopts: @session::options,
                  demitter: diagnostic::emitter) -> Session {
-    let codemap = codemap::new_codemap();
+    let codemap = @codemap::CodeMap::new();
     let diagnostic_handler =
         diagnostic::mk_handler(Some(demitter));
     let span_diagnostic_handler =
@@ -595,7 +595,7 @@ fn build_session(sopts: @session::options,
 }
 
 fn build_session_(sopts: @session::options,
-                  cm: codemap::CodeMap,
+                  cm: @codemap::CodeMap,
                   demitter: diagnostic::emitter,
                   span_diagnostic_handler: diagnostic::span_handler)
                -> Session {

branches/try2/src/librustc/driver/session.rs

@@ -131,7 +131,7 @@ type Session_ = {targ_cfg: @config,
                  opts: @options,
                  cstore: metadata::cstore::CStore,
                  parse_sess: parse_sess,
-                 codemap: codemap::CodeMap,
+                 codemap: @codemap::CodeMap,
                  // For a library crate, this is always none
                  mut main_fn: Option<(node_id, codemap::span)>,
                  span_diagnostic: diagnostic::span_handler,

branches/try2/src/librustc/metadata/encoder.rs

@@ -557,7 +557,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::Serializer,
     let add_to_index = |copy ebml_w| add_to_index_(item, ebml_w, index);
 
     debug!("encoding info for item at %s",
-           syntax::codemap::span_to_str(item.span, ecx.tcx.sess.codemap));
+           ecx.tcx.sess.codemap.span_to_str(item.span));
 
     match item.node {
       item_const(_, _) => {

branches/try2/src/librustc/middle/liveness.rs

@@ -97,7 +97,7 @@ use std::map::HashMap;
 use syntax::{visit, ast_util};
 use syntax::print::pprust::{expr_to_str, block_to_str};
 use visit::vt;
-use syntax::codemap::{span, span_to_str};
+use syntax::codemap::span;
 use syntax::ast::*;
 use io::WriterUtil;
 use capture::{cap_move, cap_drop, cap_copy, cap_ref};
@@ -170,9 +170,9 @@ impl LiveNodeKind : cmp::Eq {
 fn live_node_kind_to_str(lnk: LiveNodeKind, cx: ty::ctxt) -> ~str {
     let cm = cx.sess.codemap;
     match lnk {
-        FreeVarNode(s) => fmt!("Free var node [%s]", span_to_str(s, cm)),
-        ExprNode(s)    => fmt!("Expr node [%s]", span_to_str(s, cm)),
-        VarDefNode(s)  => fmt!("Var def node [%s]", span_to_str(s, cm)),
+        FreeVarNode(s) => fmt!("Free var node [%s]", cm.span_to_str(s)),
+        ExprNode(s)    => fmt!("Expr node [%s]", cm.span_to_str(s)),
+        VarDefNode(s)  => fmt!("Var def node [%s]", cm.span_to_str(s)),
         ExitNode       => ~"Exit node"
     }
 }

branches/try2/src/librustc/middle/trans/base.rs

@@ -919,7 +919,7 @@ fn trans_trace(bcx: block, sp_opt: Option<span>, trace_str: ~str) {
     let {V_filename, V_line} = match sp_opt {
       Some(sp) => {
         let sess = bcx.sess();
-        let loc = codemap::lookup_char_pos(sess.parse_sess.cm, sp.lo);
+        let loc = sess.parse_sess.cm.lookup_char_pos(sp.lo);
         {V_filename: C_cstr(bcx.ccx(), loc.file.name),
          V_line: loc.line as int}
       }

branches/try2/src/librustc/middle/trans/build.rs

@@ -645,7 +645,7 @@ fn _UndefReturn(cx: block, Fn: ValueRef) -> ValueRef {
 fn add_span_comment(bcx: block, sp: span, text: ~str) {
     let ccx = bcx.ccx();
     if !ccx.sess.no_asm_comments() {
-        let s = text + ~" (" + codemap::span_to_str(sp, ccx.sess.codemap)
+        let s = text + ~" (" + ccx.sess.codemap.span_to_str(sp)
             + ~")";
         log(debug, s);
         add_comment(bcx, s);

branches/try2/src/librustc/middle/trans/controlflow.rs

@@ -339,7 +339,7 @@ fn trans_fail_value(bcx: block, sp_opt: Option<span>, V_fail_str: ValueRef)
     let {V_filename, V_line} = match sp_opt {
       Some(sp) => {
         let sess = bcx.sess();
-        let loc = codemap::lookup_char_pos(sess.parse_sess.cm, sp.lo);
+        let loc = sess.parse_sess.cm.lookup_char_pos(sp.lo);
         {V_filename: C_cstr(bcx.ccx(), loc.file.name),
          V_line: loc.line as int}
       }
@@ -361,7 +361,7 @@ fn trans_fail_bounds_check(bcx: block, sp: span,
     let _icx = bcx.insn_ctxt("trans_fail_bounds_check");
     let ccx = bcx.ccx();
 
-    let loc = codemap::lookup_char_pos(bcx.sess().parse_sess.cm, sp.lo);
+    let loc = bcx.sess().parse_sess.cm.lookup_char_pos(sp.lo);
     let line = C_int(ccx, loc.line as int);
     let filename_cstr = C_cstr(bcx.ccx(), loc.file.name);
     let filename = PointerCast(bcx, filename_cstr, T_ptr(T_i8()));

branches/try2/src/librustc/middle/trans/debuginfo.rs

@@ -8,7 +8,7 @@ use trans::build::B;
 use middle::ty;
 use syntax::{ast, codemap, ast_util, ast_map};
 use syntax::parse::token::ident_interner;
-use codemap::span;
+use codemap::{span, CharPos};
 use ast::Ty;
 use pat_util::*;
 use util::ppaux::ty_to_str;
@@ -112,7 +112,7 @@ type compile_unit_md = {name: ~str};
 type subprogram_md = {id: ast::node_id};
 type local_var_md = {id: ast::node_id};
 type tydesc_md = {hash: uint};
-type block_md = {start: codemap::loc, end: codemap::loc};
+type block_md = {start: codemap::Loc, end: codemap::Loc};
 type argument_md = {id: ast::node_id};
 type retval_md = {id: ast::node_id};
 
@@ -229,8 +229,8 @@ fn create_file(cx: @crate_ctxt, full_path: ~str) -> @metadata<file_md> {
     return mdval;
 }
 
-fn line_from_span(cm: codemap::CodeMap, sp: span) -> uint {
-    codemap::lookup_char_pos(cm, sp.lo).line
+fn line_from_span(cm: @codemap::CodeMap, sp: span) -> uint {
+    cm.lookup_char_pos(sp.lo).line
 }
 
 fn create_block(cx: block) -> @metadata<block_md> {
@@ -244,9 +244,9 @@ fn create_block(cx: block) -> @metadata<block_md> {
     }
     let sp = cx.node_info.get().span;
 
-    let start = codemap::lookup_char_pos(cx.sess().codemap, sp.lo);
+    let start = cx.sess().codemap.lookup_char_pos(sp.lo);
     let fname = start.file.name;
-    let end = codemap::lookup_char_pos(cx.sess().codemap, sp.hi);
+    let end = cx.sess().codemap.lookup_char_pos(sp.hi);
     let tg = LexicalBlockTag;
     /*alt cached_metadata::<@metadata<block_md>>(
         cache, tg,
@@ -266,8 +266,8 @@ fn create_block(cx: block) -> @metadata<block_md> {
     };
     let lldata = ~[lltag(tg),
                   parent,
-                  lli32(start.line as int),
-                  lli32(start.col as int),
+                  lli32(start.line.to_int()),
+                  lli32(start.col.to_int()),
                   file_node.node,
                   lli32(unique_id)
                  ];
@@ -597,7 +597,7 @@ fn create_ty(_cx: @crate_ctxt, _t: ty::t, _ty: @ast::Ty)
 }
 
 fn filename_from_span(cx: @crate_ctxt, sp: codemap::span) -> ~str {
-    codemap::lookup_char_pos(cx.sess.codemap, sp.lo).file.name
+    cx.sess.codemap.lookup_char_pos(sp.lo).file.name
 }
 
 fn create_var(type_tag: int, context: ValueRef, name: ~str, file: ValueRef,
@@ -629,8 +629,7 @@ fn create_local_var(bcx: block, local: @ast::local)
       // FIXME this should be handled (#2533)
       _ => fail ~"no single variable name for local"
     };
-    let loc = codemap::lookup_char_pos(cx.sess.codemap,
-                                       local.span.lo);
+    let loc = cx.sess.codemap.lookup_char_pos(local.span.lo);
     let ty = node_id_type(bcx, local.node.id);
     let tymd = create_ty(cx, ty, local.node.ty);
     let filemd = create_file(cx, loc.file.name);
@@ -674,8 +673,7 @@ fn create_arg(bcx: block, arg: ast::arg, sp: span)
       option::None => ()
     }
 
-    let loc = codemap::lookup_char_pos(cx.sess.codemap,
-                                       sp.lo);
+    let loc = cx.sess.codemap.lookup_char_pos(sp.lo);
     let ty = node_id_type(bcx, arg.id);
     let tymd = create_ty(cx, ty, arg.ty);
     let filemd = create_file(cx, loc.file.name);
@@ -714,9 +712,9 @@ fn update_source_pos(cx: block, s: span) {
     }
     let cm = cx.sess().codemap;
     let blockmd = create_block(cx);
-    let loc = codemap::lookup_char_pos(cm, s.lo);
-    let scopedata = ~[lli32(loc.line as int),
-                     lli32(loc.col as int),
+    let loc = cm.lookup_char_pos(s.lo);
+    let scopedata = ~[lli32(loc.line.to_int()),
+                     lli32(loc.col.to_int()),
                      blockmd.node,
                      llnull()];
     let dbgscope = llmdnode(scopedata);
@@ -731,7 +729,7 @@ fn create_function(fcx: fn_ctxt) -> @metadata<subprogram_md> {
     log(debug, fcx.id);
 
     let sp = fcx.span.get();
-    log(debug, codemap::span_to_str(sp, cx.sess.codemap));
+    log(debug, cx.sess.codemap.span_to_str(sp));
 
     let (ident, ret_ty, id) = match cx.tcx.items.get(fcx.id) {
       ast_map::node_item(item, _) => {
@@ -773,8 +771,7 @@ fn create_function(fcx: fn_ctxt) -> @metadata<subprogram_md> {
       option::None => ()
     }
 
-    let loc = codemap::lookup_char_pos(cx.sess.codemap,
-                                       sp.lo);
+    let loc = cx.sess.codemap.lookup_char_pos(sp.lo);
     let file_node = create_file(cx, loc.file.name).node;
     let ty_node = if cx.sess.opts.extra_debuginfo {
         match ret_ty.node {

branches/try2/src/librustc/middle/typeck/collect.rs

@@ -264,7 +264,7 @@ fn ensure_supertraits(ccx: @crate_ctxt,
     for trait_refs.each |trait_ref| {
         let (did, tpt) = instantiate_trait_ref(ccx, *trait_ref, rp);
         if instantiated.any(|other_trait: &InstantiatedTraitRef|
-                            { (*other_trait).def_id == did }) {
+                            { other_trait.def_id == did }) {
             // This means a trait inherited from the same supertrait more
             // than once.
             tcx.sess.span_err(sp, ~"Duplicate supertrait in trait \