auto merge of #18840 : huonw/rust/tweaks, r=alexcrichton

Fix some old papercuts with diagnostics, e.g. tweaking spans, rewording messages. See individual commits.

src/librustc/metadata/loader.rs

@@ -307,7 +307,8 @@ impl<'a> Context<'a> {
             format!("found possibly newer version of crate `{}`",
                     self.ident)
         } else if self.rejected_via_triple.len() > 0 {
-            format!("found incorrect triple for crate `{}`", self.ident)
+            format!("couldn't find crate `{}` with expected target triple {}",
+                    self.ident, self.triple)
         } else {
             format!("can't find crate for `{}`", self.ident)
         };
@@ -318,15 +319,12 @@ impl<'a> Context<'a> {
         };
         self.sess.span_err(self.span, message.as_slice());
 
-        let mismatches = self.rejected_via_triple.iter();
         if self.rejected_via_triple.len() > 0 {
-            self.sess.span_note(self.span,
+            let mismatches = self.rejected_via_triple.iter();
-                                format!("expected triple of {}",
-                                        self.triple).as_slice());
             for (i, &CrateMismatch{ ref path, ref got }) in mismatches.enumerate() {
                 self.sess.fileline_note(self.span,
-                    format!("crate `{}` path {}{}, triple {}: {}",
+                    format!("crate `{}`, path #{}, triple {}: {}",
-                            self.ident, "#", i+1, got, path.display()).as_slice());
+                            self.ident, i+1, got, path.display()).as_slice());
             }
         }
         if self.rejected_via_hash.len() > 0 {

src/libsyntax/parse/lexer/mod.rs

@@ -806,6 +806,13 @@ impl<'a> StringReader<'a> {
                                     if ascii_only { "unknown byte escape" }
                                     else { "unknown character escape" },
                                     c);
+                                if e == '\r' {
+                                    let sp = codemap::mk_sp(escaped_pos, last_pos);
+                                    self.span_diagnostic.span_help(
+                                        sp,
+                                        "this is an isolated carriage return; consider checking \
+                                         your editor and version control settings.")
+                                }
                                 false
                             }
                         }

src/libsyntax/parse/parser.rs

@@ -66,6 +66,7 @@ use ast_util::{as_prec, ident_to_path, operator_prec};
 use ast_util;
 use codemap::{Span, BytePos, Spanned, spanned, mk_sp};
 use codemap;
+use diagnostic;
 use ext::tt::macro_parser;
 use parse;
 use parse::attr::ParserAttr;
@@ -941,6 +942,11 @@ impl<'a> Parser<'a> {
     pub fn span_fatal(&mut self, sp: Span, m: &str) -> ! {
         self.sess.span_diagnostic.span_fatal(sp, m)
     }
+    pub fn span_fatal_help(&mut self, sp: Span, m: &str, help: &str) -> ! {
+        self.span_err(sp, m);
+        self.span_help(sp, help);
+        panic!(diagnostic::FatalError);
+    }
     pub fn span_note(&mut self, sp: Span, m: &str) {
         self.sess.span_diagnostic.span_note(sp, m)
     }
@@ -1641,7 +1647,8 @@ impl<'a> Parser<'a> {
             token::LitByte(i) => LitByte(parse::byte_lit(i.as_str()).val0()),
             token::LitChar(i) => LitChar(parse::char_lit(i.as_str()).val0()),
             token::LitInteger(s) => parse::integer_lit(s.as_str(),
-                                                        &self.sess.span_diagnostic, self.span),
+                                                        &self.sess.span_diagnostic,
+                                                       self.last_span),
             token::LitFloat(s) => parse::float_lit(s.as_str()),
             token::LitStr(s) => {
                 LitStr(token::intern_and_get_ident(parse::str_lit(s.as_str()).as_slice()),
@@ -3710,7 +3717,14 @@ impl<'a> Parser<'a> {
         maybe_whole!(no_clone self, NtBlock);
 
         let lo = self.span.lo;
-        self.expect(&token::OpenDelim(token::Brace));
+
+        if !self.eat(&token::OpenDelim(token::Brace)) {
+            let sp = self.span;
+            let tok = self.this_token_to_string();
+            self.span_fatal_help(sp,
+                                 format!("expected `{{`, found `{}`", tok).as_slice(),
+                                 "place this code inside a block");
+        }
 
         return self.parse_block_tail_(lo, DefaultBlock, Vec::new());
     }
@@ -4701,9 +4715,10 @@ impl<'a> Parser<'a> {
             _ => {
                 let span = self.span;
                 let token_str = self.this_token_to_string();
-                self.span_fatal(span,
+                self.span_fatal_help(span,
                                      format!("expected `,`, or `}}`, found `{}`",
-                                        token_str).as_slice())
+                                             token_str).as_slice(),
+                                     "struct fields should be separated by commas")
             }
         }
         a_var
@@ -4905,19 +4920,24 @@ impl<'a> Parser<'a> {
                     (true, false) => (default_path, false),
                     (false, true) => (secondary_path, true),
                     (false, false) => {
-                        self.span_fatal(id_sp,
+                        self.span_fatal_help(id_sp,
-                                        format!("file not found for module \
+                                             format!("file not found for module `{}`",
-                                                 `{}`",
+                                                     mod_name).as_slice(),
-                                                 mod_name).as_slice());
+                                             format!("name the file either {} or {} inside \
+                                                     the directory {}",
+                                                     default_path_str,
+                                                     secondary_path_str,
+                                                     dir_path.display()).as_slice());
                     }
                     (true, true) => {
-                        self.span_fatal(
+                        self.span_fatal_help(
                             id_sp,
                             format!("file for module `{}` found at both {} \
                                      and {}",
                                     mod_name,
                                     default_path_str,
-                                    secondary_path_str).as_slice());
+                                    secondary_path_str).as_slice(),
+                            "delete or rename one of them to remove the ambiguity");
                     }
                 }
             }
@@ -5070,9 +5090,10 @@ impl<'a> Parser<'a> {
                     // skip the ident if there is one
                     if self.token.is_ident() { self.bump(); }
 
-                    self.span_err(span,
+                    self.span_err(span, "expected `;`, found `as`");
-                                  format!("expected `;`, found `as`; perhaps you meant \
+                    self.span_help(span,
-                                          to enclose the crate name `{}` in a string?",
+                                   format!("perhaps you meant to enclose the crate name `{}` in \
+                                           a string?",
                                           the_ident.as_str()).as_slice());
                     None
                 } else {
@@ -5582,16 +5603,12 @@ impl<'a> Parser<'a> {
         }
 
         // FAILURE TO PARSE ITEM
-        if visibility != Inherited {
+        match visibility {
-            let mut s = String::from_str("unmatched visibility `");
+            Inherited => {}
-            if visibility == Public {
+            Public => {
-                s.push_str("pub")
-            } else {
-                s.push_str("priv")
-            }
-            s.push('`');
                 let last_span = self.last_span;
-            self.span_fatal(last_span, s.as_slice());
+                self.span_fatal(last_span, "unmatched visibility `pub`");
+            }
         }
         return IoviNone(attrs);
     }
@@ -5913,4 +5930,3 @@ impl<'a> Parser<'a> {
         }
     }
 }
-

src/test/compile-fail/.gitattributes

@@ -0,0 +1 @@
+trailing-carriage-return-in-string.rs -text

src/test/compile-fail/extern-crate-as-no-string-help.rs

@@ -11,4 +11,5 @@
 // Tests that the proper help is displayed in the error message
 
 extern crate foo as bar;
-//~^ ERROR expected `;`, found `as`; perhaps you meant to enclose the crate name `foo` in a string?
+//~^ ERROR expected `;`, found `as`
+//~^^ HELP perhaps you meant to enclose the crate name `foo` in a string?

src/test/compile-fail/int-literal-too-large-span.rs

@@ -0,0 +1,17 @@
+// 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.
+
+// issue #17123
+
+fn main() {
+    100000000000000000000000000000000 //~ ERROR int literal is too large
+
+        ; // the span shouldn't point to this.
+}

src/test/compile-fail/mod_file_not_exist.rs

@@ -9,6 +9,7 @@
 // except according to those terms.
 
 mod not_a_real_file; //~ ERROR file not found for module `not_a_real_file`
+//~^ HELP name the file either not_a_real_file.rs or not_a_real_file/mod.rs inside the directory
 
 fn main() {
     assert_eq!(mod_file_aux::bar(), 10);

src/test/compile-fail/trailing-carriage-return-in-string.rs

@@ -0,0 +1,23 @@
+// 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.
+
+// ignore-tidy-cr
+// Issue #11669
+
+fn main() {
+    // \r\n
+    let ok = "This is \
+ a test";
+    // \r only
+    let bad = "This is \
 a test";
+    //~^ ERROR unknown character escape: \r
+    //~^^ HELP this is an isolated carriage return
+
+}

src/test/run-make/mismatching-target-triples/Makefile

@@ -0,0 +1,11 @@
+-include ../tools.mk
+
+# Issue #10814
+#
+# these are no_std to avoid having to have the standard library or any
+# linkers/assemblers for the relevant platform
+
+all:
+	$(RUSTC) foo.rs --target=i686-unknown-linux-gnu
+	$(RUSTC) bar.rs --target=x86_64-unknown-linux-gnu 2>&1 \
+		| grep "couldn't find crate .foo. with expected target triple x86_64-unknown-linux-gnu"

src/test/run-make/mismatching-target-triples/bar.rs

@@ -0,0 +1,11 @@
+// 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.
+#![no_std]
+extern crate foo;

src/test/run-make/mismatching-target-triples/foo.rs

@@ -0,0 +1,11 @@
+// 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.
+#![no_std]
+#![crate_type = "lib"]