---

yaml
---
r: 277978
b: refs/heads/auto
c: a4000cb
h: refs/heads/master

Author: nrc

[refs]

@@ -8,7 +8,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 43c5fef47dcaebea4c77771cc6f187b2a72b3639
+refs/heads/auto: a4000cbbf8be9f21884077bee1361b5221e1f78f
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336
 refs/tags/0.2: 1754d02027f2924bed83b0160ee340c7f41d5ea1

branches/auto/src/libcore/intrinsics.rs

@@ -192,8 +192,11 @@ extern "rust-intrinsic" {
 
     /// The size of a type in bytes.
     ///
-    /// More specifically, this is the offset in bytes between successive
-    /// items of the same type, including alignment padding.
+    /// This is the exact number of bytes in memory taken up by a
+    /// value of the given type. In other words, a memset of this size
+    /// would *exactly* overwrite a value. When laid out in vectors
+    /// and structures there may be additional padding between
+    /// elements.
     pub fn size_of<T>() -> usize;
 
     /// Moves a value to an uninitialized memory location.

branches/auto/src/libcore/mem.rs

@@ -117,9 +117,6 @@ pub fn forget<T>(t: T) {
 
 /// Returns the size of a type in bytes.
 ///
-/// More specifically, this is the offset in bytes between successive
-/// items of the same type, including alignment padding.
-///
 /// # Examples
 ///
 /// ```

branches/auto/src/librustc/diagnostics.rs

@@ -635,17 +635,7 @@ fn foo(x: u8) -> u8 {
 ```
 
 It is advisable to find out what the unhandled cases are and check for them,
-returning an appropriate value or panicking if necessary. Check if you need
-to remove a semicolon from the last expression, like in this case:
-
-```ignore
-fn foo(x: u8) -> u8 {
-    inner(2*x + 1);
-}
-```
-
-The semicolon discards the return value of `inner`, instead of returning
-it from `foo`.
+returning an appropriate value or panicking if necessary.
 "##,
 
 E0270: r##"
@@ -1579,5 +1569,5 @@ register_diagnostics! {
     E0490, // a value of type `..` is borrowed for too long
     E0491, // in type `..`, reference has a longer lifetime than the data it...
     E0495, // cannot infer an appropriate lifetime due to conflicting requirements
-    E0525, // expected a closure that implements `..` but this closure only implements `..`
+    E0524, // expected a closure that implements `..` but this closure only implements `..`
 }

branches/auto/src/librustc/infer/error_reporting.rs

@@ -249,12 +249,12 @@ pub trait ErrorReporting<'tcx> {
                                      terr: &TypeError<'tcx>)
                                      -> DiagnosticBuilder<'tcx>;
 
-    fn values_str(&self, values: &ValuePairs<'tcx>) -> Option<(String, String)>;
+    fn values_str(&self, values: &ValuePairs<'tcx>) -> Option<String>;
 
     fn expected_found_str<T: fmt::Display + Resolvable<'tcx> + TypeFoldable<'tcx>>(
         &self,
         exp_found: &ty::error::ExpectedFound<T>)
-        -> Option<(String, String)>;
+        -> Option<String>;
 
     fn report_concrete_failure(&self,
                                origin: SubregionOrigin<'tcx>,
@@ -535,7 +535,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
                          trace: TypeTrace<'tcx>,
                          terr: &TypeError<'tcx>)
                          -> DiagnosticBuilder<'tcx> {
-        let (expected, found) = match self.values_str(&trace.values) {
+        let expected_found_str = match self.values_str(&trace.values) {
             Some(v) => v,
             None => {
                 return self.tcx.sess.diagnostic().struct_dummy(); /* derived error */
@@ -548,17 +548,18 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
             false
         };
 
+        let expected_found_str = if is_simple_error {
+            expected_found_str
+        } else {
+            format!("{} ({})", expected_found_str, terr)
+        };
+
         let mut err = struct_span_err!(self.tcx.sess,
                                        trace.origin.span(),
                                        E0308,
-                                       "{}",
-                                       trace.origin);
-
-        if !is_simple_error {
-            err = err.note_expected_found(&"type", &expected, &found);
-        }
-
-        err = err.span_label(trace.origin.span(), &terr);
+                                       "{}: {}",
+                                       trace.origin,
+                                       expected_found_str);
 
         self.check_and_note_conflicting_crates(&mut err, terr, trace.origin.span());
 
@@ -573,7 +574,6 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
             },
             _ => ()
         }
-
         err
     }
 
@@ -631,7 +631,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
 
     /// Returns a string of the form "expected `{}`, found `{}`", or None if this is a derived
     /// error.
-    fn values_str(&self, values: &ValuePairs<'tcx>) -> Option<(String, String)> {
+    fn values_str(&self, values: &ValuePairs<'tcx>) -> Option<String> {
         match *values {
             infer::Types(ref exp_found) => self.expected_found_str(exp_found),
             infer::TraitRefs(ref exp_found) => self.expected_found_str(exp_found),
@@ -642,7 +642,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
     fn expected_found_str<T: fmt::Display + Resolvable<'tcx> + TypeFoldable<'tcx>>(
         &self,
         exp_found: &ty::error::ExpectedFound<T>)
-        -> Option<(String, String)>
+        -> Option<String>
     {
         let expected = exp_found.expected.resolve(self);
         if expected.references_error() {
@@ -654,7 +654,9 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
             return None;
         }
 
-        Some((format!("{}", expected), format!("{}", found)))
+        Some(format!("expected `{}`, found `{}`",
+                     expected,
+                     found))
     }
 
     fn report_generic_bound_failure(&self,
@@ -682,9 +684,10 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
                                                E0309,
                                                "{} may not live long enough",
                                                labeled_user_string);
-                err.help(&format!("consider adding an explicit lifetime bound `{}: {}`...",
-                         bound_kind,
-                         sub));
+                err.fileline_help(origin.span(),
+                                  &format!("consider adding an explicit lifetime bound `{}: {}`...",
+                                           bound_kind,
+                                           sub));
                 err
             }
 
@@ -695,9 +698,10 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
                                                E0310,
                                                "{} may not live long enough",
                                                labeled_user_string);
-                err.help(&format!("consider adding an explicit lifetime \
-                                   bound `{}: 'static`...",
-                                  bound_kind));
+                err.fileline_help(origin.span(),
+                                  &format!("consider adding an explicit lifetime \
+                                            bound `{}: 'static`...",
+                                           bound_kind));
                 err
             }
 
@@ -708,8 +712,9 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
                                                E0311,
                                                "{} may not live long enough",
                                                labeled_user_string);
-                err.help(&format!("consider adding an explicit lifetime bound for `{}`",
-                                  bound_kind));
+                err.fileline_help(origin.span(),
+                                  &format!("consider adding an explicit lifetime bound for `{}`",
+                                           bound_kind));
                 self.tcx.note_and_explain_region(
                     &mut err,
                     &format!("{} must be valid for ", labeled_user_string),
@@ -1746,11 +1751,11 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> {
                 };
 
                 match self.values_str(&trace.values) {
-                    Some((expected, found)) => {
+                    Some(values_str) => {
                         err.span_note(
                             trace.origin.span(),
-                            &format!("...so that {} (expected {}, found {})",
-                                    desc, expected, found));
+                            &format!("...so that {} ({})",
+                                    desc, values_str));
                     }
                     None => {
                         // Really should avoid printing this error at

branches/auto/src/librustc/lint/context.rs

@@ -456,13 +456,17 @@ pub fn raw_struct_lint<'a>(sess: &'a Session,
                                    it will become a hard error in a future release!");
         let citation = format!("for more information, see {}",
                                future_incompatible.reference);
-        err.warn(&explanation);
-        err.note(&citation);
+        if let Some(sp) = span {
+            err.fileline_warn(sp, &explanation);
+            err.fileline_note(sp, &citation);
+        } else {
+            err.warn(&explanation);
+            err.note(&citation);
+        }
     }
 
     if let Some(span) = def {
-        let explanation = "lint level defined here";
-        err.span_note(span, &explanation);
+        err.span_note(span, "lint level defined here");
     }
 
     err
@@ -538,7 +542,7 @@ pub trait LintContext: Sized {
         let mut err = self.lookup(lint, Some(span), msg);
         if self.current_level(lint) != Level::Allow {
             if note_span == span {
-                err.note(note);
+                err.fileline_note(note_span, note);
             } else {
                 err.span_note(note_span, note);
             }

branches/auto/src/librustc/session/config.rs

@@ -48,9 +48,7 @@ pub enum OptLevel {
     No, // -O0
     Less, // -O1
     Default, // -O2
-    Aggressive, // -O3
-    Size, // -Os
-    SizeMin, // -Oz
+    Aggressive // -O3
 }
 
 #[derive(Clone, Copy, PartialEq)]
@@ -569,8 +567,8 @@ options! {CodegenOptions, CodegenSetter, basic_codegen_options,
     debuginfo: Option<usize> = (None, parse_opt_uint,
         "debug info emission level, 0 = no debug info, 1 = line tables only, \
          2 = full debug info with variable and type information"),
-    opt_level: Option<String> = (None, parse_opt_string,
-        "optimize with possible levels 0-3, s, or z"),
+    opt_level: Option<usize> = (None, parse_opt_uint,
+        "optimize with possible levels 0-3"),
     debug_assertions: Option<bool> = (None, parse_opt_bool,
         "explicitly enable the cfg(debug_assertions) directive"),
     inline_threshold: Option<usize> = (None, parse_opt_uint,
@@ -1127,20 +1125,13 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options {
             }
             OptLevel::Default
         } else {
-            match (cg.opt_level.as_ref().map(String::as_ref),
-                   nightly_options::is_nightly_build()) {
-                (None, _) => OptLevel::No,
-                (Some("0"), _) => OptLevel::No,
-                (Some("1"), _) => OptLevel::Less,
-                (Some("2"), _) => OptLevel::Default,
-                (Some("3"), _) => OptLevel::Aggressive,
-                (Some("s"), true) => OptLevel::Size,
-                (Some("z"), true) => OptLevel::SizeMin,
-                (Some("s"), false) | (Some("z"), false) => {
-                    early_error(error_format, &format!("the optimizations s or z are only \
-                                                        accepted on the nightly compiler"));
-                },
-                (Some(arg), _) => {
+            match cg.opt_level {
+                None => OptLevel::No,
+                Some(0) => OptLevel::No,
+                Some(1) => OptLevel::Less,
+                Some(2) => OptLevel::Default,
+                Some(3) => OptLevel::Aggressive,
+                Some(arg) => {
                     early_error(error_format, &format!("optimization level needs to be \
                                                       between 0-3 (instead was `{}`)",
                                                      arg));
@@ -1313,7 +1304,7 @@ pub mod nightly_options {
         is_nightly_build() && matches.opt_strs("Z").iter().any(|x| *x == "unstable-options")
     }
 
-    pub fn is_nightly_build() -> bool {
+    fn is_nightly_build() -> bool {
         match get_unstable_features_setting() {
             UnstableFeatures::Allow | UnstableFeatures::Cheat => true,
             _ => false,

branches/auto/src/librustc/session/mod.rs

@@ -567,7 +567,7 @@ pub fn early_error(output: config::ErrorOutputType, msg: &str) -> ! {
         }
         config::ErrorOutputType::Json => Box::new(JsonEmitter::basic()),
     };
-    emitter.emit(&MultiSpan::new(), msg, None, errors::Level::Fatal);
+    emitter.emit(None, msg, None, errors::Level::Fatal);
     panic!(errors::FatalError);
 }
 
@@ -578,7 +578,7 @@ pub fn early_warn(output: config::ErrorOutputType, msg: &str) {
         }
         config::ErrorOutputType::Json => Box::new(JsonEmitter::basic()),
     };
-    emitter.emit(&MultiSpan::new(), msg, None, errors::Level::Warning);
+    emitter.emit(None, msg, None, errors::Level::Warning);
 }
 
 // Err(0) means compilation was stopped, but no errors were found.