---

yaml
---
r: 56511
b: refs/heads/auto
c: 9968ccf
h: refs/heads/master
i:
  56509: 8584beb
  56507: c12eb3b
  56503: 40a7805
  56495: 17d36fd
  56479: 447d045
  56447: 0e10a78
v: v3

Author: danluu

[refs]

@@ -14,6 +14,6 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 41af2792333fe739abb899c6815005b08674ff21
+refs/heads/auto: 9968ccfc303f6cc6fed614118400faabcb9a6760
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c

branches/auto/src/librustc/driver/driver.rs

@@ -149,7 +149,7 @@ pub fn parse_input(sess: Session, cfg: ast::crate_cfg, input: &input)
     -> @ast::crate {
     match *input {
       file_input(ref file) => {
-        parse::parse_crate_from_file(&(*file), cfg, sess.parse_sess)
+        parse::parse_crate_from_file_using_tts(&(*file), cfg, sess.parse_sess)
       }
       str_input(ref src) => {
         // FIXME (#2319): Don't really want to box the source string

branches/auto/src/librustdoc/attr_parser.rs

@@ -79,7 +79,7 @@ mod test {
 
         let parse_sess = syntax::parse::new_parse_sess(None);
         let parser = parse::new_parser_from_source_str(
-            parse_sess, ~[], ~"-", @source);
+            parse_sess, ~[], ~"-", codemap::FssNone, @source);
 
         parser.parse_outer_attributes()
     }

branches/auto/src/libsyntax/ast_util.rs

@@ -355,10 +355,6 @@ pub fn operator_prec(op: ast::binop) -> uint {
   }
 }
 
-/// Precedence of the `as` operator, which is a binary operator
-/// not appearing in the prior table.
-pub static as_prec: uint = 11u;
-
 pub fn dtor_ty() -> @ast::Ty {
     @ast::Ty {id: 0, node: ty_nil, span: dummy_sp()}
 }
@@ -760,6 +756,7 @@ mod test {
         assert_eq!(refold_test_sc(3,&t),test_sc);
     }
 
+
     // extend a syntax context with a sequence of marks given
     // in a vector. v[0] will be the outermost mark.
     fn unfold_marks(mrks:~[Mrk],tail:SyntaxContext,table: &mut SCTable) -> SyntaxContext {

branches/auto/src/libsyntax/ext/base.rs

@@ -461,7 +461,9 @@ impl <K: Eq + Hash + IterBytes ,V: Copy> MapChain<K,V>{
 
     // ugh: can't get this to compile with mut because of the
     // lack of flow sensitivity.
-    #[cfg(not(stage0))]
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    #[cfg(stage3)]
     fn get_map<'a>(&'a self) -> &'a HashMap<K,@V> {
         match *self {
             BaseMapChain (~ref map) => map,

branches/auto/src/libsyntax/opt_vec.rs

@@ -68,7 +68,9 @@ impl<T> OptVec<T> {
         }
     }
 
-    #[cfg(not(stage0))]
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    #[cfg(stage3)]
     fn get<'a>(&'a self, i: uint) -> &'a T {
         match *self {
             Empty => fail!(fmt!("Invalid index %u", i)),

branches/auto/src/libsyntax/parse/attr.rs

@@ -62,14 +62,12 @@ impl parser_attr for Parser {
         return attrs;
     }
 
-    // matches attribute = # attribute_naked
     fn parse_attribute(&self, style: ast::attr_style) -> ast::attribute {
         let lo = self.span.lo;
         self.expect(&token::POUND);
         return self.parse_attribute_naked(style, lo);
     }
 
-    // matches attribute_naked = [ meta_item ]
     fn parse_attribute_naked(&self, style: ast::attr_style, lo: BytePos) ->
         ast::attribute {
         self.expect(&token::LBRACKET);
@@ -88,7 +86,6 @@ impl parser_attr for Parser {
     // is an inner attribute of the containing item or an outer attribute of
     // the first contained item until we see the semi).
 
-    // matches inner_attrs* outer_attr?
     // you can make the 'next' field an Option, but the result is going to be
     // more useful as a vector.
     fn parse_inner_attrs_and_next(&self) ->
@@ -137,9 +134,6 @@ impl parser_attr for Parser {
         (inner_attrs, next_outer_attrs)
     }
 
-    // matches meta_item = IDENT
-    // | IDENT = lit
-    // | IDENT meta_seq
     fn parse_meta_item(&self) -> @ast::meta_item {
         let lo = self.span.lo;
         let name = self.id_to_str(self.parse_ident());
@@ -162,7 +156,6 @@ impl parser_attr for Parser {
         }
     }
 
-    // matches meta_seq = ( COMMASEP(meta_item) )
     fn parse_meta_seq(&self) -> ~[@ast::meta_item] {
         copy self.parse_seq(
             &token::LPAREN,

branches/auto/src/libsyntax/parse/classify.rs

@@ -15,13 +15,6 @@
 use ast;
 use codemap;
 
-// does this expression require a semicolon to be treated
-// as a statement? The negation of this: 'can this expression
-// be used as a statement without a semicolon' -- is used
-// as an early-bail-out in the parser so that, for instance,
-// 'if true {...} else {...}
-//  |x| 5 '
-// isn't parsed as (if true {...} else {...} | x) | 5
 pub fn expr_requires_semi_to_be_stmt(e: @ast::expr) -> bool {
     match e.node {
       ast::expr_if(*)
@@ -47,9 +40,6 @@ pub fn expr_is_simple_block(e: @ast::expr) -> bool {
     }
 }
 
-// this statement requires a semicolon after it.
-// note that in one case (stmt_semi), we've already
-// seen the semicolon, and thus don't need another.
 pub fn stmt_ends_with_semi(stmt: &ast::stmt) -> bool {
     return match stmt.node {
         ast::stmt_decl(d, _) => {

branches/auto/src/libsyntax/parse/comments.rs

@@ -309,8 +309,6 @@ pub struct lit {
     pos: BytePos
 }
 
-// it appears this function is called only from pprust... that's
-// probably not a good thing.
 pub fn gather_comments_and_literals(span_diagnostic:
                                     @diagnostic::span_handler,
                                     path: ~str,

branches/auto/src/libsyntax/parse/lexer.rs

@@ -225,12 +225,20 @@ pub fn is_whitespace(c: char) -> bool {
     return c == ' ' || c == '\t' || c == '\r' || c == '\n';
 }
 
+fn may_begin_ident(c: char) -> bool { return is_alpha(c) || c == '_'; }
+
 fn in_range(c: char, lo: char, hi: char) -> bool {
     return lo <= c && c <= hi
 }
 
+fn is_alpha(c: char) -> bool {
+    return in_range(c, 'a', 'z') || in_range(c, 'A', 'Z');
+}
+
 fn is_dec_digit(c: char) -> bool { return in_range(c, '0', '9'); }
 
+fn is_alnum(c: char) -> bool { return is_alpha(c) || is_dec_digit(c); }
+
 fn is_hex_digit(c: char) -> bool {
     return in_range(c, '0', '9') || in_range(c, 'a', 'f') ||
             in_range(c, 'A', 'F');
@@ -286,8 +294,6 @@ fn consume_any_line_comment(rdr: @mut StringReader)
         }
     } else if rdr.curr == '#' {
         if nextch(rdr) == '!' {
-            // I guess this is the only way to figure out if
-            // we're at the beginning of the file...
             let cmap = @CodeMap::new();
             (*cmap).files.push(rdr.filemap);
             let loc = cmap.lookup_char_pos_adj(rdr.last_pos);
@@ -438,7 +444,8 @@ fn scan_number(c: char, rdr: @mut StringReader) -> token::Token {
         }
     }
     let mut is_float = false;
-    if rdr.curr == '.' && !(ident_start(nextch(rdr)) || nextch(rdr) == '.') {
+    if rdr.curr == '.' && !(is_alpha(nextch(rdr)) || nextch(rdr) == '_' ||
+                            nextch(rdr) == '.') {
         is_float = true;
         bump(rdr);
         let dec_part = scan_digits(rdr, 10u);