---

yaml
---
r: 227646
b: refs/heads/try
c: 2e997ef
h: refs/heads/master
v: v3

Author: eddyb

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: aca2057ed5fb7af3f8905b2bc01f72fa001c35c8
 refs/heads/snap-stage3: 1af31d4974e33027a68126fa5a5a3c2c6491824f
-refs/heads/try: 89485b2b6b643019c1748d456898c8774e2331de
+refs/heads/try: 2e997ef2d487525ea41e78ba793cb6e7c61cb204
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/src/librustc/diagnostics.rs

@@ -256,21 +256,6 @@ See [RFC 911] for more details on the design of `const fn`s.
 [RFC 911]: https://github.com/rust-lang/rfcs/blob/master/text/0911-const-fn.md
 "##,
 
-E0016: r##"
-Blocks in constants may only contain items (such as constant, function
-definition, etc...) and a tail expression. Example:
-
-```
-const FOO: i32 = { let x = 0; x }; // 'x' isn't an item!
-```
-
-To avoid it, you have to replace the non-item object:
-
-```
-const FOO: i32 = { const X : i32 = 0; X };
-```
-"##,
-
 E0018: r##"
 The value of static and const variables must be known at compile time. You
 can't cast a pointer as an integer because we can't know what value the
@@ -294,42 +279,6 @@ println!("{}", Y);
 ```
 "##,
 
-E0019: r##"
-A function call isn't allowed in the const's initialization expression
-because the expression's value must be known at compile-time. Example of
-erroneous code:
-
-```
-enum Test {
-    V1
-}
-
-impl Test {
-    fn test(&self) -> i32 {
-        12
-    }
-}
-
-fn main() {
-    const FOO: Test = Test::V1;
-
-    const A: i32 = FOO.test(); // You can't call Test::func() here !
-}
-```
-
-Remember: you can't use a function call inside a const's initialization
-expression! However, you can totally use it elsewhere you want:
-
-```
-fn main() {
-    const FOO: Test = Test::V1;
-
-    FOO.func(); // here is good
-    let x = FOO.func(); // or even here!
-}
-```
-"##,
-
 E0020: r##"
 This error indicates that an attempt was made to divide by zero (or take the
 remainder of a zero divisor) in a static or constant expression.
@@ -1001,7 +950,9 @@ static mut BAR: Option<Vec<i32>> = None;
 
 
 register_diagnostics! {
+    E0016,
     E0017,
+    E0019,
     E0022,
     E0038,
     E0109,

branches/try/src/librustc/middle/ty.rs

@@ -101,11 +101,10 @@ pub const INITIAL_DISCRIMINANT_VALUE: Disr = 0;
 
 /// The complete set of all analyses described in this module. This is
 /// produced by the driver and fed to trans and later passes.
-pub struct CrateAnalysis<'tcx> {
+pub struct CrateAnalysis {
     pub export_map: ExportMap,
     pub exported_items: middle::privacy::ExportedItems,
     pub public_items: middle::privacy::PublicItems,
-    pub ty_cx: ty::ctxt<'tcx>,
     pub reachable: NodeSet,
     pub name: String,
     pub glob_map: Option<GlobMap>,

branches/try/src/librustc_driver/driver.rs

@@ -119,26 +119,26 @@ pub fn compile_input(sess: Session,
                                                                      &ast_map.krate(),
                                                                      &id[..]));
 
-        let analysis = phase_3_run_analysis_passes(sess,
-                                                   ast_map,
-                                                   &arenas,
-                                                   id,
-                                                   control.make_glob_map);
+        let (tcx, analysis) = phase_3_run_analysis_passes(sess,
+                                                          ast_map,
+                                                          &arenas,
+                                                          id,
+                                                          control.make_glob_map);
 
         controller_entry_point!(after_analysis,
-                                analysis.ty_cx.sess,
+                                tcx.sess,
                                 CompileState::state_after_analysis(input,
-                                                                   &analysis.ty_cx.sess,
+                                                                   &tcx.sess,
                                                                    outdir,
-                                                                   analysis.ty_cx.map.krate(),
+                                                                   tcx.map.krate(),
                                                                    &analysis,
-                                                                   &analysis.ty_cx));
+                                                                   &tcx));
 
         if log_enabled!(::log::INFO) {
             println!("Pre-trans");
-            analysis.ty_cx.print_debug_stats();
+            tcx.print_debug_stats();
         }
-        let (tcx, trans) = phase_4_translate_to_llvm(analysis);
+        let trans = phase_4_translate_to_llvm(&tcx, analysis);
 
         if log_enabled!(::log::INFO) {
             println!("Post-trans");
@@ -240,7 +240,7 @@ pub struct CompileState<'a, 'ast: 'a, 'tcx: 'a> {
     pub out_dir: Option<&'a Path>,
     pub expanded_crate: Option<&'a ast::Crate>,
     pub ast_map: Option<&'a ast_map::Map<'ast>>,
-    pub analysis: Option<&'a ty::CrateAnalysis<'tcx>>,
+    pub analysis: Option<&'a ty::CrateAnalysis>,
     pub tcx: Option<&'a ty::ctxt<'tcx>>,
     pub trans: Option<&'a trans::CrateTranslation>,
 }
@@ -309,7 +309,7 @@ impl<'a, 'ast, 'tcx> CompileState<'a, 'ast, 'tcx> {
                             session: &'a Session,
                             out_dir: &'a Option<PathBuf>,
                             expanded_crate: &'a ast::Crate,
-                            analysis: &'a ty::CrateAnalysis<'tcx>,
+                            analysis: &'a ty::CrateAnalysis,
                             tcx: &'a ty::ctxt<'tcx>)
                             -> CompileState<'a, 'ast, 'tcx> {
         CompileState {
@@ -583,7 +583,7 @@ pub fn phase_3_run_analysis_passes<'tcx>(sess: Session,
                                          arenas: &'tcx ty::CtxtArenas<'tcx>,
                                          name: String,
                                          make_glob_map: resolve::MakeGlobMap)
-                                         -> ty::CrateAnalysis<'tcx> {
+                                         -> (ty::ctxt<'tcx>, ty::CrateAnalysis) {
     let time_passes = sess.time_passes();
     let krate = ast_map.krate();
 
@@ -704,29 +704,28 @@ pub fn phase_3_run_analysis_passes<'tcx>(sess: Session,
     // The above three passes generate errors w/o aborting
     ty_cx.sess.abort_if_errors();
 
-    ty::CrateAnalysis {
+    (ty_cx, ty::CrateAnalysis {
         export_map: export_map,
-        ty_cx: ty_cx,
         exported_items: exported_items,
         public_items: public_items,
         reachable: reachable_map,
         name: name,
         glob_map: glob_map,
-    }
+    })
 }
 
 /// Run the translation phase to LLVM, after which the AST and analysis can
 /// be discarded.
-pub fn phase_4_translate_to_llvm<'tcx>(analysis: ty::CrateAnalysis<'tcx>)
-                                       -> (ty::ctxt<'tcx>, trans::CrateTranslation) {
-    let time_passes = analysis.ty_cx.sess.time_passes();
+pub fn phase_4_translate_to_llvm(tcx: &ty::ctxt, analysis: ty::CrateAnalysis)
+                                 -> trans::CrateTranslation {
+    let time_passes = tcx.sess.time_passes();
 
     time(time_passes, "resolving dependency formats", (), |_|
-         dependency_format::calculate(&analysis.ty_cx));
+         dependency_format::calculate(tcx));
 
     // Option dance to work around the lack of stack once closures.
     time(time_passes, "translation", analysis, |analysis|
-         trans::trans_crate(analysis))
+         trans::trans_crate(tcx, analysis))
 }
 
 /// Run LLVM itself, producing a bitcode file, assembly file or object file

branches/try/src/librustc_driver/lib.rs

@@ -377,12 +377,10 @@ impl<'a> CompilerCalls<'a> for RustcDefaultCalls {
         if sess.opts.debugging_opts.save_analysis {
             control.after_analysis.callback = box |state| {
                 time(state.session.time_passes(),
-                     "save analysis",
-                     state.expanded_crate.unwrap(),
-                     |krate| save::process_crate(state.session,
-                                                 krate,
-                                                 state.analysis.unwrap(),
-                                                 state.out_dir));
+                     "save analysis", (),
+                     |_| save::process_crate(state.tcx.unwrap(),
+                                             state.analysis.unwrap(),
+                                             state.out_dir));
             };
             control.make_glob_map = resolve::MakeGlobMap::Yes;
         }

branches/try/src/librustc_driver/pretty.rs

@@ -148,12 +148,12 @@ impl PpSourceMode {
             }
             PpmTyped => {
                 let ast_map = ast_map.expect("--pretty=typed missing ast_map");
-                let analysis = driver::phase_3_run_analysis_passes(sess,
+                let (tcx, _) = driver::phase_3_run_analysis_passes(sess,
                                                                    ast_map,
                                                                    arenas,
                                                                    id,
                                                                    resolve::MakeGlobMap::No);
-                let annotation = TypedAnnotation { analysis: analysis };
+                let annotation = TypedAnnotation { tcx: tcx };
                 f(&annotation, payload)
             }
         }
@@ -285,14 +285,14 @@ impl<'ast> pprust::PpAnn for HygieneAnnotation<'ast> {
 
 
 struct TypedAnnotation<'tcx> {
-    analysis: ty::CrateAnalysis<'tcx>,
+    tcx: ty::ctxt<'tcx>,
 }
 
 impl<'tcx> PrinterSupport<'tcx> for TypedAnnotation<'tcx> {
-    fn sess<'a>(&'a self) -> &'a Session { &self.analysis.ty_cx.sess }
+    fn sess<'a>(&'a self) -> &'a Session { &self.tcx.sess }
 
     fn ast_map<'a>(&'a self) -> Option<&'a ast_map::Map<'tcx>> {
-        Some(&self.analysis.ty_cx.map)
+        Some(&self.tcx.map)
     }
 
     fn pp_ann<'a>(&'a self) -> &'a pprust::PpAnn { self }
@@ -310,16 +310,15 @@ impl<'tcx> pprust::PpAnn for TypedAnnotation<'tcx> {
     fn post(&self,
             s: &mut pprust::State,
             node: pprust::AnnNode) -> io::Result<()> {
-        let tcx = &self.analysis.ty_cx;
         match node {
             pprust::NodeExpr(expr) => {
                 try!(pp::space(&mut s.s));
                 try!(pp::word(&mut s.s, "as"));
                 try!(pp::space(&mut s.s));
                 try!(pp::word(&mut s.s,
                               &ppaux::ty_to_string(
-                                  tcx,
-                                  ty::expr_ty(tcx, expr))));
+                                  &self.tcx,
+                                  ty::expr_ty(&self.tcx, expr))));
                 s.pclose()
             }
             _ => Ok(())
@@ -646,12 +645,12 @@ pub fn pretty_print_input(sess: Session,
             match code {
                 Some(code) => {
                     let variants = gather_flowgraph_variants(&sess);
-                    let analysis = driver::phase_3_run_analysis_passes(sess,
+                    let (tcx, _) = driver::phase_3_run_analysis_passes(sess,
                                                                        ast_map,
                                                                        &arenas,
                                                                        id,
                                                                        resolve::MakeGlobMap::No);
-                    print_flowgraph(variants, analysis, code, mode, out)
+                    print_flowgraph(variants, &tcx, code, mode, out)
                 }
                 None => {
                     let message = format!("--pretty=flowgraph needs \
@@ -682,18 +681,17 @@ pub fn pretty_print_input(sess: Session,
 }
 
 fn print_flowgraph<W: Write>(variants: Vec<borrowck_dot::Variant>,
-                             analysis: ty::CrateAnalysis,
+                             tcx: &ty::ctxt,
                              code: blocks::Code,
                              mode: PpFlowGraphMode,
                              mut out: W) -> io::Result<()> {
-    let ty_cx = &analysis.ty_cx;
     let cfg = match code {
-        blocks::BlockCode(block) => cfg::CFG::new(ty_cx, &*block),
-        blocks::FnLikeCode(fn_like) => cfg::CFG::new(ty_cx, &*fn_like.body()),
+        blocks::BlockCode(block) => cfg::CFG::new(tcx, &*block),
+        blocks::FnLikeCode(fn_like) => cfg::CFG::new(tcx, &*fn_like.body()),
     };
     let labelled_edges = mode != PpFlowGraphMode::UnlabelledEdges;
     let lcfg = LabelledCFG {
-        ast_map: &ty_cx.map,
+        ast_map: &tcx.map,
         cfg: &cfg,
         name: format!("node_{}", code.id()),
         labelled_edges: labelled_edges,
@@ -705,14 +703,14 @@ fn print_flowgraph<W: Write>(variants: Vec<borrowck_dot::Variant>,
             return expand_err_details(r);
         }
         blocks::BlockCode(_) => {
-            ty_cx.sess.err("--pretty flowgraph with -Z flowgraph-print \
-                            annotations requires fn-like node id.");
+            tcx.sess.err("--pretty flowgraph with -Z flowgraph-print \
+                          annotations requires fn-like node id.");
             return Ok(())
         }
         blocks::FnLikeCode(fn_like) => {
             let fn_parts = borrowck::FnPartsWithCFG::from_fn_like(&fn_like, &cfg);
             let (bccx, analysis_data) =
-                borrowck::build_borrowck_dataflow_data_for_fn(ty_cx, fn_parts);
+                borrowck::build_borrowck_dataflow_data_for_fn(tcx, fn_parts);
 
             let lcfg = borrowck_dot::DataflowLabeller {
                 inner: lcfg,