---

yaml
---
r: 134331
b: refs/heads/auto
c: 3514737
h: refs/heads/master
i:
  134329: 3c799fa
  134327: 1bc0da4
v: v3

Author: Jakub Wieczorek

[refs]

@@ -13,7 +13,7 @@ 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: 9c39b6c564745d4e316c16b6b8bf04675520253b
+refs/heads/auto: 3514737b4cf1d91dc8c7b61c95f2f20d3b386d1c
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

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

@@ -3480,32 +3480,22 @@ impl<'a> Parser<'a> {
         })
     }
 
-    /// Get an expected item after attributes error message.
-    fn expected_item_err(attrs: &[Attribute]) -> &'static str {
-        match attrs.last() {
-            Some(&Attribute { node: ast::Attribute_ { is_sugared_doc: true, .. }, .. }) => {
-                "expected item after doc comment"
-            }
-            _ => "expected item after attributes",
-        }
-    }
-
     /// Parse a statement. may include decl.
     /// Precondition: any attributes are parsed already
     pub fn parse_stmt(&mut self, item_attrs: Vec<Attribute>) -> P<Stmt> {
         maybe_whole!(self, NtStmt);
 
-        fn check_expected_item(p: &mut Parser, attrs: &[Attribute]) {
+        fn check_expected_item(p: &mut Parser, found_attrs: bool) {
             // If we have attributes then we should have an item
-            if !attrs.is_empty() {
+            if found_attrs {
                 let last_span = p.last_span;
-                p.span_err(last_span, Parser::expected_item_err(attrs));
+                p.span_err(last_span, "expected item after attributes");
             }
         }
 
         let lo = self.span.lo;
         if self.is_keyword(keywords::Let) {
-            check_expected_item(self, item_attrs.as_slice());
+            check_expected_item(self, !item_attrs.is_empty());
             self.expect_keyword(keywords::Let);
             let decl = self.parse_let();
             P(spanned(lo, decl.span.hi, StmtDecl(decl, ast::DUMMY_NODE_ID)))
@@ -3514,7 +3504,7 @@ impl<'a> Parser<'a> {
             && self.look_ahead(1, |t| *t == token::NOT) {
             // it's a macro invocation:
 
-            check_expected_item(self, item_attrs.as_slice());
+            check_expected_item(self, !item_attrs.is_empty());
 
             // Potential trouble: if we allow macros with paths instead of
             // idents, we'd need to look ahead past the whole path here...
@@ -3571,7 +3561,6 @@ impl<'a> Parser<'a> {
 
         } else {
             let found_attrs = !item_attrs.is_empty();
-            let item_err = Parser::expected_item_err(item_attrs.as_slice());
             match self.parse_item_or_view_item(item_attrs, false) {
                 IoviItem(i) => {
                     let hi = i.span.hi;
@@ -3586,10 +3575,7 @@ impl<'a> Parser<'a> {
                     self.fatal("foreign items are not allowed here");
                 }
                 IoviNone(_) => {
-                    if found_attrs {
-                        let last_span = self.last_span;
-                        self.span_err(last_span, item_err);
-                    }
+                    check_expected_item(self, found_attrs);
 
                     // Remainder are line-expr stmts.
                     let e = self.parse_expr_res(RestrictionStmtExpr);
@@ -3667,8 +3653,7 @@ impl<'a> Parser<'a> {
                 token::SEMI => {
                     if !attributes_box.is_empty() {
                         let last_span = self.last_span;
-                        self.span_err(last_span,
-                                      Parser::expected_item_err(attributes_box.as_slice()));
+                        self.span_err(last_span, "expected item after attributes");
                         attributes_box = Vec::new();
                     }
                     self.bump(); // empty
@@ -3754,8 +3739,7 @@ impl<'a> Parser<'a> {
 
         if !attributes_box.is_empty() {
             let last_span = self.last_span;
-            self.span_err(last_span,
-                          Parser::expected_item_err(attributes_box.as_slice()));
+            self.span_err(last_span, "expected item after attributes");
         }
 
         let hi = self.span.hi;
@@ -4701,8 +4685,7 @@ impl<'a> Parser<'a> {
         if first && attrs_remaining_len > 0u {
             // We parsed attributes for the first item but didn't find it
             let last_span = self.last_span;
-            self.span_err(last_span,
-                          Parser::expected_item_err(attrs_remaining.as_slice()));
+            self.span_err(last_span, "expected item after attributes");
         }
 
         ast::Mod {
@@ -4936,10 +4919,10 @@ impl<'a> Parser<'a> {
             items: _,
             foreign_items: foreign_items
         } = self.parse_foreign_items(first_item_attrs, true);
-        if !attrs_remaining.is_empty() {
+        if ! attrs_remaining.is_empty() {
             let last_span = self.last_span;
             self.span_err(last_span,
-                          Parser::expected_item_err(attrs_remaining.as_slice()));
+                          "expected item after attributes");
         }
         assert!(self.token == token::RBRACE);
         ast::ForeignMod {
@@ -5069,7 +5052,7 @@ impl<'a> Parser<'a> {
     fn parse_enum_def(&mut self, _generics: &ast::Generics) -> EnumDef {
         let mut variants = Vec::new();
         let mut all_nullary = true;
-        let mut have_disr = false;
+        let mut any_disr = None;
         while self.token != token::RBRACE {
             let variant_attrs = self.parse_outer_attributes();
             let vlo = self.span.lo;
@@ -5101,8 +5084,8 @@ impl<'a> Parser<'a> {
                 }
                 kind = TupleVariantKind(args);
             } else if self.eat(&token::EQ) {
-                have_disr = true;
                 disr_expr = Some(self.parse_expr());
+                any_disr = disr_expr.as_ref().map(|expr| expr.span);
                 kind = TupleVariantKind(args);
             } else {
                 kind = TupleVariantKind(Vec::new());
@@ -5121,9 +5104,11 @@ impl<'a> Parser<'a> {
             if !self.eat(&token::COMMA) { break; }
         }
         self.expect(&token::RBRACE);
-        if have_disr && !all_nullary {
-            self.fatal("discriminator values can only be used with a c-like \
-                        enum");
+        match any_disr {
+            Some(disr_span) if !all_nullary =>
+                self.span_err(disr_span,
+                    "discriminator values can only be used with a c-like enum"),
+            _ => ()
         }
 
         ast::EnumDef { variants: variants }

branches/auto/src/test/compile-fail/attr-before-eof.rs

@@ -1,4 +1,4 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// 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.
 //
@@ -8,8 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn main() {
-    /// hi
-    println!("hi");
-    //~^^ ERROR expected item after doc comment
+enum X {
+    A =
+        b'a' //~ ERROR discriminator values can only be used with a c-like enum
+    ,
+    B(int)
 }
+
+fn main() {}

branches/auto/src/test/compile-fail/doc-before-attr.rs

@@ -12,7 +12,6 @@
 // older versions of GDB too. A more extensive test can be found in
 // gdb-pretty-struct-and-enums.rs
 
-// ignore-windows failing on win32 bot
 // ignore-tidy-linelength
 // ignore-lldb
 // ignore-android: FIXME(#10381)

branches/auto/src/test/compile-fail/doc-before-eof.rs

@@ -8,7 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// ignore-windows failing on win32 bot
 // ignore-tidy-linelength
 // ignore-lldb
 // ignore-android: FIXME(#10381)