---

yaml
---
r: 277593
b: refs/heads/try
c: 780f725
h: refs/heads/master
i:
  277591: 25cdf33

Author: birkenfeld

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 6dbb0e86aec11050480beb76eade6fb805010ba7
 refs/heads/snap-stage3: 235d77457d80b549dad3ac36d94f235208a1eafb
-refs/heads/try: 7d8100a068151512774caf15a6a88766ca9cf434
+refs/heads/try: 780f725176e0fb8f37ef67564dd9ff1ee01f29c2
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/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/try/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/try/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##"

branches/try/src/librustc_const_eval/check_match.rs

@@ -341,15 +341,7 @@ fn check_arms(cx: &MatchCheckCtxt,
                         },
 
                         hir::MatchSource::Normal => {
-                            let mut err = struct_span_err!(cx.tcx.sess, pat.span, E0001,
-                                                           "unreachable pattern");
-                            // if we had a catchall pattern, hint at that
-                            for row in &seen.0 {
-                                if pat_is_catchall(&cx.tcx.def_map.borrow(), row[0]) {
-                                    span_note!(err, row[0].span, "this pattern matches any value");
-                                }
-                            }
-                            err.emit();
+                            span_err!(cx.tcx.sess, pat.span, E0001, "unreachable pattern")
                         },
 
                         hir::MatchSource::TryDesugar => {
@@ -369,18 +361,7 @@ fn check_arms(cx: &MatchCheckCtxt,
     }
 }
 
-/// Checks for common cases of "catchall" patterns that may not be intended as such.
-fn pat_is_catchall(dm: &DefMap, p: &Pat) -> bool {
-    match p.node {
-        PatKind::Ident(_, _, None) => pat_is_binding(dm, p),
-        PatKind::Ident(_, _, Some(ref s)) => pat_is_catchall(dm, &s),
-        PatKind::Ref(ref s, _) => pat_is_catchall(dm, &s),
-        PatKind::Tup(ref v) => v.iter().all(|p| pat_is_catchall(dm, &p)),
-        _ => false
-    }
-}
-
-fn raw_pat(p: &Pat) -> &Pat {
+fn raw_pat<'a>(p: &'a Pat) -> &'a Pat {
     match p.node {
         PatKind::Ident(_, _, Some(ref s)) => raw_pat(&s),
         _ => p

branches/try/src/librustc_driver/driver.rs

@@ -70,7 +70,7 @@ pub fn compile_input(sess: &Session,
                      control: &CompileController) -> CompileResult {
     macro_rules! controller_entry_point {
         ($point: ident, $tsess: expr, $make_state: expr, $phase_result: expr) => {{
-            let state = &mut $make_state;
+            let state = $make_state;
             let phase_result: &CompileResult = &$phase_result;
             if phase_result.is_ok() || control.$point.run_callback_on_error {
                 (control.$point.callback)(state);
@@ -95,24 +95,17 @@ pub fn compile_input(sess: &Session,
                 }
             };
 
-            let mut compile_state = CompileState::state_after_parse(input,
-                                                                    sess,
-                                                                    outdir,
-                                                                    output,
-                                                                    krate,
-                                                                    &cstore);
             controller_entry_point!(after_parse,
                                     sess,
-                                    compile_state,
+                                    CompileState::state_after_parse(input, sess, outdir, &krate),
                                     Ok(()));
-            let krate = compile_state.krate.unwrap();
 
             let outputs = build_output_filenames(input, outdir, output, &krate.attrs, sess);
             let id = link::find_crate_name(Some(sess), &krate.attrs, input);
             let expanded_crate = phase_2_configure_and_expand(sess,
                                                               &cstore,
                                                               krate,
-                                                              &id,
+                                                              &id[..],
                                                               addl_plugins)?;
 
             (outputs, expanded_crate, id)
@@ -123,10 +116,8 @@ pub fn compile_input(sess: &Session,
                                 CompileState::state_after_expand(input,
                                                                  sess,
                                                                  outdir,
-                                                                 output,
-                                                                 &cstore,
                                                                  &expanded_crate,
-                                                                 &id),
+                                                                 &id[..]),
                                 Ok(()));
 
         let expanded_crate = assign_node_ids(sess, expanded_crate);
@@ -171,13 +162,10 @@ pub fn compile_input(sess: &Session,
                                     CompileState::state_after_write_deps(input,
                                                                          sess,
                                                                          outdir,
-                                                                         output,
-                                                                         &arenas,
-                                                                         &cstore,
                                                                          &hir_map,
                                                                          &expanded_crate,
                                                                          &hir_map.krate(),
-                                                                         &id),
+                                                                         &id[..]),
                                     Ok(()));
         }
 
@@ -206,17 +194,16 @@ pub fn compile_input(sess: &Session,
                 // Eventually, we will want to track plugins.
                 let _ignore = tcx.dep_graph.in_ignore();
 
-                let mut state = CompileState::state_after_analysis(input,
-                                                                   sess,
-                                                                   outdir,
-                                                                   output,
-                                                                   opt_crate,
-                                                                   tcx.map.krate(),
-                                                                   &analysis,
-                                                                   mir_map.as_ref(),
-                                                                   tcx,
-                                                                   &id);
-                (control.after_analysis.callback)(&mut state);
+                let state = CompileState::state_after_analysis(input,
+                                                               &tcx.sess,
+                                                               outdir,
+                                                               opt_crate,
+                                                               tcx.map.krate(),
+                                                               &analysis,
+                                                               mir_map.as_ref(),
+                                                               tcx,
+                                                               &id);
+                (control.after_analysis.callback)(state);
 
                 if control.after_analysis.stop == Compilation::Stop {
                     return result.and_then(|_| Err(0usize));
@@ -249,7 +236,7 @@ pub fn compile_input(sess: &Session,
 
     controller_entry_point!(after_llvm,
                             sess,
-                            CompileState::state_after_llvm(input, sess, outdir, output, &trans),
+                            CompileState::state_after_llvm(input, sess, outdir, &trans),
                             phase5_result);
     phase5_result?;
 
@@ -324,7 +311,7 @@ pub struct PhaseController<'a> {
     // If true then the compiler will try to run the callback even if the phase
     // ends with an error. Note that this is not always possible.
     pub run_callback_on_error: bool,
-    pub callback: Box<Fn(&mut CompileState) + 'a>,
+    pub callback: Box<Fn(CompileState) -> () + 'a>,
 }
 
 impl<'a> PhaseController<'a> {
@@ -340,38 +327,34 @@ impl<'a> PhaseController<'a> {
 /// State that is passed to a callback. What state is available depends on when
 /// during compilation the callback is made. See the various constructor methods
 /// (`state_*`) in the impl to see which data is provided for any given entry point.
-pub struct CompileState<'a, 'b, 'ast: 'a, 'tcx: 'b> where 'ast: 'tcx {
+pub struct CompileState<'a, 'ast: 'a, 'tcx: 'a> {
     pub input: &'a Input,
-    pub session: &'ast Session,
-    pub krate: Option<ast::Crate>,
-    pub cstore: Option<&'a CStore>,
+    pub session: &'a Session,
+    pub cfg: Option<&'a ast::CrateConfig>,
+    pub krate: Option<&'a ast::Crate>,
     pub crate_name: Option<&'a str>,
     pub output_filenames: Option<&'a OutputFilenames>,
     pub out_dir: Option<&'a Path>,
-    pub out_file: Option<&'a Path>,
-    pub arenas: Option<&'ast ty::CtxtArenas<'ast>>,
     pub expanded_crate: Option<&'a ast::Crate>,
     pub hir_crate: Option<&'a hir::Crate>,
     pub ast_map: Option<&'a hir_map::Map<'ast>>,
-    pub mir_map: Option<&'b MirMap<'tcx>>,
+    pub mir_map: Option<&'a MirMap<'tcx>>,
     pub analysis: Option<&'a ty::CrateAnalysis<'a>>,
-    pub tcx: Option<&'b TyCtxt<'tcx>>,
+    pub tcx: Option<&'a TyCtxt<'tcx>>,
     pub trans: Option<&'a trans::CrateTranslation>,
 }
 
-impl<'a, 'b, 'ast, 'tcx> CompileState<'a, 'b, 'ast, 'tcx> {
+impl<'a, 'ast, 'tcx> CompileState<'a, 'ast, 'tcx> {
     fn empty(input: &'a Input,
-             session: &'ast Session,
+             session: &'a Session,
              out_dir: &'a Option<PathBuf>)
-             -> CompileState<'a, 'b, 'ast, 'tcx> {
+             -> CompileState<'a, 'ast, 'tcx> {
         CompileState {
             input: input,
             session: session,
             out_dir: out_dir.as_ref().map(|s| &**s),
-            out_file: None,
-            arenas: None,
+            cfg: None,
             krate: None,
-            cstore: None,
             crate_name: None,
             output_filenames: None,
             expanded_crate: None,
@@ -385,95 +368,71 @@ impl<'a, 'b, 'ast, 'tcx> CompileState<'a, 'b, 'ast, 'tcx> {
     }
 
     fn state_after_parse(input: &'a Input,
-                         session: &'ast Session,
+                         session: &'a Session,
                          out_dir: &'a Option<PathBuf>,
-                         out_file: &'a Option<PathBuf>,
-                         krate: ast::Crate,
-                         cstore: &'a CStore)
-                         -> CompileState<'a, 'b, 'ast, 'tcx> {
-        CompileState {
-            krate: Some(krate),
-            cstore: Some(cstore),
-            out_file: out_file.as_ref().map(|s| &**s),
-            ..CompileState::empty(input, session, out_dir)
-        }
+                         krate: &'a ast::Crate)
+                         -> CompileState<'a, 'ast, 'tcx> {
+        CompileState { krate: Some(krate), ..CompileState::empty(input, session, out_dir) }
     }
 
     fn state_after_expand(input: &'a Input,
-                          session: &'ast Session,
+                          session: &'a Session,
                           out_dir: &'a Option<PathBuf>,
-                          out_file: &'a Option<PathBuf>,
-                          cstore: &'a CStore,
                           expanded_crate: &'a ast::Crate,
                           crate_name: &'a str)
-                          -> CompileState<'a, 'b, 'ast, 'tcx> {
+                          -> CompileState<'a, 'ast, 'tcx> {
         CompileState {
             crate_name: Some(crate_name),
-            cstore: Some(cstore),
             expanded_crate: Some(expanded_crate),
-            out_file: out_file.as_ref().map(|s| &**s),
             ..CompileState::empty(input, session, out_dir)
         }
     }
 
     fn state_after_write_deps(input: &'a Input,
-                              session: &'ast Session,
+                              session: &'a Session,
                               out_dir: &'a Option<PathBuf>,
-                              out_file: &'a Option<PathBuf>,
-                              arenas: &'ast ty::CtxtArenas<'ast>,
-                              cstore: &'a CStore,
                               hir_map: &'a hir_map::Map<'ast>,
                               krate: &'a ast::Crate,
                               hir_crate: &'a hir::Crate,
                               crate_name: &'a str)
-                              -> CompileState<'a, 'b, 'ast, 'tcx> {
+                              -> CompileState<'a, 'ast, 'tcx> {
         CompileState {
             crate_name: Some(crate_name),
-            arenas: Some(arenas),
-            cstore: Some(cstore),
             ast_map: Some(hir_map),
-            expanded_crate: Some(krate),
+            krate: Some(krate),
             hir_crate: Some(hir_crate),
-            out_file: out_file.as_ref().map(|s| &**s),
             ..CompileState::empty(input, session, out_dir)
         }
     }
 
     fn state_after_analysis(input: &'a Input,
-                            session: &'ast Session,
+                            session: &'a Session,
                             out_dir: &'a Option<PathBuf>,
-                            out_file: &'a Option<PathBuf>,
                             krate: Option<&'a ast::Crate>,
                             hir_crate: &'a hir::Crate,
-                            analysis: &'a ty::CrateAnalysis<'a>,
-                            mir_map: Option<&'b MirMap<'tcx>>,
-                            tcx: &'b TyCtxt<'tcx>,
+                            analysis: &'a ty::CrateAnalysis,
+                            mir_map: Option<&'a MirMap<'tcx>>,
+                            tcx: &'a TyCtxt<'tcx>,
                             crate_name: &'a str)
-                            -> CompileState<'a, 'b, 'ast, 'tcx> {
+                            -> CompileState<'a, 'ast, 'tcx> {
         CompileState {
             analysis: Some(analysis),
             mir_map: mir_map,
             tcx: Some(tcx),
-            expanded_crate: krate,
+            krate: krate,
             hir_crate: Some(hir_crate),
             crate_name: Some(crate_name),
-            out_file: out_file.as_ref().map(|s| &**s),
             ..CompileState::empty(input, session, out_dir)
         }
     }
 
 
     fn state_after_llvm(input: &'a Input,
-                        session: &'ast Session,
+                        session: &'a Session,
                         out_dir: &'a Option<PathBuf>,
-                        out_file: &'a Option<PathBuf>,
                         trans: &'a trans::CrateTranslation)
-                        -> CompileState<'a, 'b, 'ast, 'tcx> {
-        CompileState {
-            trans: Some(trans),
-            out_file: out_file.as_ref().map(|s| &**s),
-            ..CompileState::empty(input, session, out_dir)
-        }
+                        -> CompileState<'a, 'ast, 'tcx> {
+        CompileState { trans: Some(trans), ..CompileState::empty(input, session, out_dir) }
     }
 }
 
@@ -839,16 +798,16 @@ pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: &'tcx Session,
     let index = stability::Index::new(&hir_map);
 
     TyCtxt::create_and_enter(sess,
-                             arenas,
-                             def_map,
-                             named_region_map,
-                             hir_map,
-                             freevars,
-                             region_map,
-                             lang_items,
-                             index,
-                             name,
-                             |tcx| {
+                               arenas,
+                               def_map,
+                               named_region_map,
+                               hir_map,
+                               freevars,
+                               region_map,
+                               lang_items,
+                               index,
+                               name,
+                               |tcx| {
         time(time_passes,
              "load_dep_graph",
              || rustc_incremental::load_dep_graph(tcx));