---

yaml
---
r: 149694
b: refs/heads/try2
c: df40aec
h: refs/heads/master
v: v3

Author: pcwalton

[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: baf79083aedb8ae64efddbcf28b358841cfd1157
+refs/heads/try2: df40aeccdbfcfb0cc7851c6df24f28fbeccfe046
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

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

@@ -1145,26 +1145,12 @@ fn list_crate_deps(data: &[u8], out: &mut io::Writer) -> io::IoResult<()> {
     Ok(())
 }
 
-pub fn maybe_get_crate_hash(data: &[u8]) -> Option<Svh> {
-    let cratedoc = reader::Doc(data);
-    reader::maybe_get_doc(cratedoc, tag_crate_hash).map(|doc| {
-        Svh::new(doc.as_str_slice())
-    })
-}
-
 pub fn get_crate_hash(data: &[u8]) -> Svh {
     let cratedoc = reader::Doc(data);
     let hashdoc = reader::get_doc(cratedoc, tag_crate_hash);
     Svh::new(hashdoc.as_str_slice())
 }
 
-pub fn maybe_get_crate_id(data: &[u8]) -> Option<CrateId> {
-    let cratedoc = reader::Doc(data);
-    reader::maybe_get_doc(cratedoc, tag_crate_crateid).map(|doc| {
-        from_str(doc.as_str_slice()).unwrap()
-    })
-}
-
 pub fn get_crate_id(data: &[u8]) -> CrateId {
     let cratedoc = reader::Doc(data);
     let hashdoc = reader::get_doc(cratedoc, tag_crate_crateid);

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

@@ -318,17 +318,12 @@ impl<'a> Context<'a> {
     }
 
     fn crate_matches(&mut self, crate_data: &[u8]) -> bool {
-        match decoder::maybe_get_crate_id(crate_data) {
-            Some(ref id) if self.crate_id.matches(id) => {}
-            _ => return false
-        }
-        let hash = match decoder::maybe_get_crate_hash(crate_data) {
-            Some(hash) => hash, None => return false
-        };
+        let other_id = decoder::get_crate_id(crate_data);
+        if !self.crate_id.matches(&other_id) { return false }
         match self.hash {
             None => true,
-            Some(myhash) => {
-                if *myhash != hash {
+            Some(hash) => {
+                if *hash != decoder::get_crate_hash(crate_data) {
                     self.rejected_via_hash = true;
                     false
                 } else {

branches/try2/src/librustdoc/html/highlight.rs

@@ -26,7 +26,7 @@ use html::escape::Escape;
 use t = syntax::parse::token;
 
 /// Highlights some source code, returning the HTML output.
-pub fn highlight(src: &str, class: Option<&str>) -> ~str {
+pub fn highlight(src: &str) -> ~str {
     let sess = parse::new_parse_sess();
     let handler = diagnostic::default_handler();
     let span_handler = diagnostic::mk_span_handler(handler, sess.cm);
@@ -35,7 +35,6 @@ pub fn highlight(src: &str, class: Option<&str>) -> ~str {
     let mut out = io::MemWriter::new();
     doit(sess,
          lexer::new_string_reader(span_handler, fm),
-         class,
          &mut out).unwrap();
     str::from_utf8_lossy(out.unwrap()).into_owned()
 }
@@ -47,15 +46,14 @@ pub fn highlight(src: &str, class: Option<&str>) -> ~str {
 /// it's used. All source code emission is done as slices from the source map,
 /// not from the tokens themselves, in order to stay true to the original
 /// source.
-fn doit(sess: @parse::ParseSess, lexer: lexer::StringReader, class: Option<&str>,
+fn doit(sess: @parse::ParseSess, lexer: lexer::StringReader,
         out: &mut Writer) -> io::IoResult<()> {
     use syntax::parse::lexer::Reader;
 
-    try!(write!(out, "<pre class='rust {}'>\n", class.unwrap_or("")));
+    try!(write!(out, "<pre class='rust'>\n"));
     let mut last = BytePos(0);
     let mut is_attribute = false;
     let mut is_macro = false;
-    let mut is_macro_nonterminal = false;
     loop {
         let next = lexer.next_token();
         let test = if next.tok == t::EOF {lexer.pos.get()} else {next.sp.lo};
@@ -103,15 +101,8 @@ fn doit(sess: @parse::ParseSess, lexer: lexer::StringReader, class: Option<&str>
             // miscellaneous, no highlighting
             t::DOT | t::DOTDOT | t::DOTDOTDOT | t::COMMA | t::SEMI |
                 t::COLON | t::MOD_SEP | t::LARROW | t::DARROW | t::LPAREN |
-                t::RPAREN | t::LBRACKET | t::LBRACE | t::RBRACE => "",
-            t::DOLLAR => {
-                if t::is_ident(&lexer.peek().tok) {
-                    is_macro_nonterminal = true;
-                    "macro-nonterminal"
-                } else {
-                    ""
-                }
-            }
+                t::RPAREN | t::LBRACKET | t::LBRACE | t::RBRACE |
+                t::DOLLAR => "",
 
             // This is the start of an attribute. We're going to want to
             // continue highlighting it as an attribute until the ending ']' is
@@ -152,10 +143,7 @@ fn doit(sess: @parse::ParseSess, lexer: lexer::StringReader, class: Option<&str>
 
                     _ if t::is_any_keyword(&next.tok) => "kw",
                     _ => {
-                        if is_macro_nonterminal {
-                            is_macro_nonterminal = false;
-                            "macro-nonterminal"
-                        } else if lexer.peek().tok == t::NOT {
+                        if lexer.peek().tok == t::NOT {
                             is_macro = true;
                             "macro"
                         } else {
@@ -183,3 +171,4 @@ fn doit(sess: @parse::ParseSess, lexer: lexer::StringReader, class: Option<&str>
 
     write!(out, "</pre>\n")
 }
+

branches/try2/src/librustdoc/html/markdown.rs

@@ -146,7 +146,7 @@ pub fn render(w: &mut io::Writer, s: &str) -> fmt::Result {
                 };
 
                 if !rendered {
-                    let output = highlight::highlight(text, None).to_c_str();
+                    let output = highlight::highlight(text).to_c_str();
                     output.with_ref(|r| {
                         bufputs(ob, r)
                     })

branches/try2/src/librustdoc/html/render.rs

@@ -1630,13 +1630,13 @@ impl<'a> fmt::Show for Source<'a> {
             try!(write!(fmt.buf, "<span id='{0:u}'>{0:1$u}</span>\n", i, cols));
         }
         try!(write!(fmt.buf, "</pre>"));
-        try!(write!(fmt.buf, "{}", highlight::highlight(s.as_slice(), None)));
+        try!(write!(fmt.buf, "{}", highlight::highlight(s.as_slice())));
         Ok(())
     }
 }
 
 fn item_macro(w: &mut Writer, it: &clean::Item,
               t: &clean::Macro) -> fmt::Result {
-    try!(w.write_str(highlight::highlight(t.source, Some("macro"))));
+    try!(write!(w, "<pre class='macro'>{}</pre>", t.source));
     document(w, it)
 }

branches/try2/src/librustdoc/html/static/main.css

@@ -315,7 +315,6 @@ pre.rust .op { color: #cc782f; }
 pre.rust .comment { color: #533add; }
 pre.rust .doccomment { color: #d343d0; }
 pre.rust .macro { color: #d343d0; }
-pre.rust .macro-nonterminal { color: #d343d0; }
 pre.rust .string { color: #c13928; }
 pre.rust .lifetime { color: #d343d0; }
 pre.rust .attribute { color: #d343d0 !important; }

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

@@ -70,6 +70,7 @@ use option::{Option, Some, None};
 use rc::Rc;
 use str::{Str, StrSlice};
 use vec::{Vector, ImmutableVector};
+use vec_ng::Vec;
 
 /// Reexport the `sip::hash` function as our default hasher.
 pub use hash = self::sip::hash;
@@ -207,6 +208,13 @@ impl<S: Writer, T: Hash<S>> Hash<S> for ~[T] {
     }
 }
 
+impl<S: Writer, T: Hash<S>> Hash<S> for Vec<T> {
+    #[inline]
+    fn hash(&self, state: &mut S) {
+        self.as_slice().hash(state);
+    }
+}
+
 impl<'a, S: Writer, T: Hash<S>> Hash<S> for &'a T {
     #[inline]
     fn hash(&self, state: &mut S) {

branches/try2/src/libstd/vec_ng.rs

@@ -15,6 +15,7 @@ use cast::{forget, transmute};
 use clone::Clone;
 use cmp::{Eq, Ordering, TotalEq, TotalOrd};
 use container::Container;
+use default::Default;
 use iter::{DoubleEndedIterator, FromIterator, Iterator};
 use libc::{free, c_void};
 use mem::{size_of, move_val_init};
@@ -26,7 +27,8 @@ use ptr::RawPtr;
 use ptr;
 use rt::global_heap::{malloc_raw, realloc_raw};
 use raw::Slice;
-use vec::{ImmutableVector, Items, MutItems, MutableVector, RevItems};
+use vec::{ImmutableEqVector, ImmutableVector, Items, MutItems, MutableVector};
+use vec::{RevItems};
 
 pub struct Vec<T> {
     priv len: uint,
@@ -340,6 +342,18 @@ impl<T> Vec<T> {
     pub fn slice_from<'a>(&'a self, start: uint) -> &'a [T] {
         self.as_slice().slice_from(start)
     }
+
+    #[inline]
+    pub fn init<'a>(&'a self) -> &'a [T] {
+        self.slice(0, self.len() - 1)
+    }
+}
+
+impl<T:Eq> Vec<T> {
+    /// Return true if a vector contains an element with the given value
+    pub fn contains(&self, x: &T) -> bool {
+        self.as_slice().contains(x)
+    }
 }
 
 #[inline]
@@ -348,6 +362,14 @@ pub fn append<T:Clone>(mut first: Vec<T>, second: &[T]) -> Vec<T> {
     first
 }
 
+/// Appends one element to the vector provided. The vector itself is then
+/// returned for use again.
+#[inline]
+pub fn append_one<T>(mut lhs: Vec<T>, x: T) -> Vec<T> {
+    lhs.push(x);
+    lhs
+}
+
 #[unsafe_destructor]
 impl<T> Drop for Vec<T> {
     fn drop(&mut self) {
@@ -360,6 +382,12 @@ impl<T> Drop for Vec<T> {
     }
 }
 
+impl<T> Default for Vec<T> {
+    fn default() -> Vec<T> {
+        Vec::new()
+    }
+}
+
 pub struct MoveItems<T> {
     priv allocation: *mut c_void, // the block of memory allocated for the vector
     priv iter: Items<'static, T>