---

yaml
---
r: 148959
b: refs/heads/try2
c: 104002b
h: refs/heads/master
i:
  148957: dca0056
  148955: 6af4918
  148951: d6f1992
  148943: a51886d
  148927: a421b16
v: v3

Author: sanxiyn

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 14cb4be6e90d0c5eb42a3eef58d083acc8e51837
+refs/heads/try2: 104002be6ff9636f897434bd588da398c34dc1f0
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

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

@@ -518,6 +518,10 @@ pub fn compile_input(sess: Session, cfg: ast::CrateConfig, input: &Input,
     let (outputs, trans) = {
         let (expanded_crate, ast_map) = {
             let crate = phase_1_parse_input(sess, cfg, input);
+            if sess.show_span() {
+                front::show_span::run(sess, &crate);
+                return;
+            }
             if stop_after_phase_1(sess) { return; }
             let loader = &mut Loader::new(sess);
             phase_2_configure_and_expand(sess, loader, crate)

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

@@ -60,6 +60,7 @@ debugging_opts!(
         BORROWCK_STATS,
         NO_LANDING_PADS,
         DEBUG_LLVM,
+        SHOW_SPAN,
         COUNT_TYPE_SIZES,
         META_STATS,
         NO_OPT,
@@ -95,6 +96,7 @@ pub fn debugging_opts_map() -> ~[(&'static str, &'static str, u64)] {
      ("no-landing-pads", "omit landing pads for unwinding",
       NO_LANDING_PADS),
      ("debug-llvm", "enable debug output from LLVM", DEBUG_LLVM),
+     ("show-span", "show spans", SHOW_SPAN),
      ("count-type-sizes", "count the sizes of aggregate types",
       COUNT_TYPE_SIZES),
      ("meta-stats", "gather metadata statistics", META_STATS),
@@ -351,6 +353,9 @@ impl Session_ {
     pub fn no_landing_pads(&self) -> bool {
         self.debugging_opt(NO_LANDING_PADS)
     }
+    pub fn show_span(&self) -> bool {
+        self.debugging_opt(SHOW_SPAN)
+    }
 
     // DEPRECATED. This function results in a lot of allocations when they
     // are not necessary.

branches/try2/src/librustc/front/show_span.rs

@@ -0,0 +1,31 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use syntax::ast;
+use syntax::visit;
+use syntax::visit::Visitor;
+
+use driver::session::Session;
+
+struct ShowSpanVisitor {
+    sess: Session
+}
+
+impl Visitor<()> for ShowSpanVisitor {
+    fn visit_expr(&mut self, e: &ast::Expr, _: ()) {
+        self.sess.span_note(e.span, "expression");
+        visit::walk_expr(self, e, ());
+    }
+}
+
+pub fn run(sess: Session, crate: &ast::Crate) {
+    let mut v = ShowSpanVisitor { sess: sess };
+    visit::walk_crate(&mut v, crate, ());
+}

branches/try2/src/librustc/lib.rs

@@ -97,6 +97,7 @@ pub mod front {
     pub mod std_inject;
     pub mod assign_node_ids_and_map;
     pub mod feature_gate;
+    pub mod show_span;
 }
 
 pub mod back {

branches/try2/src/libsemver/lib.rs

@@ -35,7 +35,6 @@
 
 use std::char;
 use std::cmp;
-use std::fmt;
 use std::option::{Option, Some, None};
 use std::to_str::ToStr;
 
@@ -60,20 +59,13 @@ impl cmp::Ord for Identifier {
     }
 }
 
-impl fmt::Show for Identifier {
-    #[inline]
-    fn fmt(version: &Identifier, f: &mut fmt::Formatter) -> fmt::Result {
-        match *version {
-            Numeric(ref n) => fmt::Show::fmt(n, f),
-            AlphaNumeric(ref s) => fmt::Show::fmt(s, f)
-        }
-    }
-}
-
 impl ToStr for Identifier {
     #[inline]
     fn to_str(&self) -> ~str {
-        format!("{}", *self)
+        match self {
+            &Numeric(n) => n.to_str(),
+            &AlphaNumeric(ref s) => s.to_str()
+        }
     }
 }
 
@@ -82,45 +74,33 @@ impl ToStr for Identifier {
 #[deriving(Clone, Eq)]
 pub struct Version {
     /// The major version, to be incremented on incompatible changes.
-    major: uint,
+    priv major: uint,
     /// The minor version, to be incremented when functionality is added in a
     /// backwards-compatible manner.
-    minor: uint,
+    priv minor: uint,
     /// The patch version, to be incremented when backwards-compatible bug
     /// fixes are made.
-    patch: uint,
+    priv patch: uint,
     /// The pre-release version identifier, if one exists.
-    pre: ~[Identifier],
+    priv pre: ~[Identifier],
     /// The build metadata, ignored when determining version precedence.
-    build: ~[Identifier],
-}
-
-impl fmt::Show for Version {
-    #[inline]
-    fn fmt(version: &Version, f: &mut fmt::Formatter) -> fmt::Result {
-        if_ok!(write!(f.buf, "{}.{}.{}", version.major, version.minor, version.patch))
-        if !version.pre.is_empty() {
-            if_ok!(write!(f.buf, "-"));
-            for (i, x) in version.pre.iter().enumerate() {
-                if i != 0 { if_ok!(write!(f.buf, ".")) };
-                if_ok!(fmt::Show::fmt(x, f));
-            }
-        }
-        if !version.build.is_empty() {
-            if_ok!(write!(f.buf, "+"));
-            for (i, x) in version.build.iter().enumerate() {
-                if i != 0 { if_ok!(write!(f.buf, ".")) };
-                if_ok!(fmt::Show::fmt(x, f));
-            }
-        }
-        Ok(())
-    }
+    priv build: ~[Identifier],
 }
 
 impl ToStr for Version {
     #[inline]
     fn to_str(&self) -> ~str {
-        format!("{}", *self)
+        let s = format!("{}.{}.{}", self.major, self.minor, self.patch);
+        let s = if self.pre.is_empty() {
+            s
+        } else {
+            format!("{}-{}", s, self.pre.map(|i| i.to_str()).connect("."))
+        };
+        if self.build.is_empty() {
+            s
+        } else {
+            format!("{}+{}", s, self.build.map(|i| i.to_str()).connect("."))
+        }
     }
 }
 
@@ -385,22 +365,6 @@ fn test_ne() {
     assert!(parse("1.2.3+23")    != parse("1.2.3+42"));
 }
 
-#[test]
-fn test_show() {
-    assert_eq!(format!("{}", parse("1.2.3").unwrap()), ~"1.2.3");
-    assert_eq!(format!("{}", parse("1.2.3-alpha1").unwrap()), ~"1.2.3-alpha1");
-    assert_eq!(format!("{}", parse("1.2.3+build.42").unwrap()), ~"1.2.3+build.42");
-    assert_eq!(format!("{}", parse("1.2.3-alpha1+42").unwrap()), ~"1.2.3-alpha1+42");
-}
-
-#[test]
-fn test_to_str() {
-    assert_eq!(parse("1.2.3").unwrap().to_str(), ~"1.2.3");
-    assert_eq!(parse("1.2.3-alpha1").unwrap().to_str(), ~"1.2.3-alpha1");
-    assert_eq!(parse("1.2.3+build.42").unwrap().to_str(), ~"1.2.3+build.42");
-    assert_eq!(parse("1.2.3-alpha1+42").unwrap().to_str(), ~"1.2.3-alpha1+42");
-}
-
 #[test]
 fn test_lt() {
     assert!(parse("0.0.0")        < parse("1.2.3-alpha2"));

branches/try2/src/libstd/path/mod.rs

@@ -508,10 +508,10 @@ impl<'a, P: GenericPath> ToStr for Display<'a, P> {
         if self.filename {
             match self.path.filename() {
                 None => ~"",
-                Some(v) => str::from_utf8_lossy(v)
+                Some(v) => from_utf8_with_replacement(v)
             }
         } else {
-            str::from_utf8_lossy(self.path.as_vec())
+            from_utf8_with_replacement(self.path.as_vec())
         }
     }
 }
@@ -596,6 +596,29 @@ fn contains_nul(v: &[u8]) -> bool {
     v.iter().any(|&x| x == 0)
 }
 
+#[inline(always)]
+fn from_utf8_with_replacement(mut v: &[u8]) -> ~str {
+    // FIXME (#9516): Don't decode utf-8 manually here once we have a good way to do it in str
+    // This is a truly horrifically bad implementation, done as a functionality stopgap until
+    // we have a proper utf-8 decoder. I don't really want to write one here.
+    static REPLACEMENT_CHAR: char = '\uFFFD';
+
+    let mut s = str::with_capacity(v.len());
+    while !v.is_empty() {
+        let w = str::utf8_char_width(v[0]);
+        if w == 0u {
+            s.push_char(REPLACEMENT_CHAR);
+            v = v.slice_from(1);
+        } else if v.len() < w || !str::is_utf8(v.slice_to(w)) {
+            s.push_char(REPLACEMENT_CHAR);
+            v = v.slice_from(1);
+        } else {
+            s.push_str(unsafe { ::cast::transmute(v.slice_to(w)) });
+            v = v.slice_from(w);
+        }
+    }
+    s
+}
 #[cfg(test)]
 mod tests {
     use prelude::*;