---

yaml
---
r: 274669
b: refs/heads/stable
c: a1ffe6b
h: refs/heads/master
i:
  274667: 6a198cd

Author: alexcrichton

[refs]

@@ -29,7 +29,7 @@ refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: c0221c8897db309a79990367476177b1230bb264
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: f8fa6140fa6a85ea21ef4d2d56764862f7b3728b
+refs/heads/stable: a1ffe6b6bbfec7374f91dbbfb2e51a3fa5fadb1e
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

branches/stable/src/liballoc/arc.rs

@@ -380,9 +380,9 @@ impl<T: ?Sized> Deref for Arc<T> {
 }
 
 impl<T: Clone> Arc<T> {
-    /// Make a mutable reference into the given `Arc<T>`.
-    /// If the `Arc<T>` has more than one strong reference, or any weak
-    /// references, the inner data is cloned.
+    /// Make a mutable reference into the given `Arc<T>` by cloning the inner
+    /// data if the `Arc<T>` doesn't have one strong reference and no weak
+    /// references.
     ///
     /// This is also referred to as a copy-on-write.
     ///

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

@@ -163,6 +163,7 @@ pub enum PrintRequest {
     FileNames,
     Sysroot,
     CrateName,
+    Cfg,
 }
 
 pub enum Input {
@@ -1105,6 +1106,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options {
             "crate-name" => PrintRequest::CrateName,
             "file-names" => PrintRequest::FileNames,
             "sysroot" => PrintRequest::Sysroot,
+            "cfg" => PrintRequest::Cfg,
             req => {
                 early_error(error_format, &format!("unknown print request `{}`", req))
             }

branches/stable/src/librustc_driver/lib.rs

@@ -518,6 +518,25 @@ impl RustcDefaultCalls {
                                       .to_string_lossy());
                     }
                 }
+                PrintRequest::Cfg => {
+                    for cfg in config::build_configuration(sess) {
+                        match cfg.node {
+                            ast::MetaWord(ref word) => println!("{}", word),
+                            ast::MetaNameValue(ref name, ref value) => {
+                                println!("{}=\"{}\"", name, match value.node {
+                                    ast::LitStr(ref s, _) => s,
+                                    _ => continue,
+                                });
+                            }
+                            // Right now there are not and should not be any
+                            // MetaList items in the configuration returned by
+                            // `build_configuration`.
+                            ast::MetaList(..) => {
+                                panic!("MetaList encountered in default cfg")
+                            }
+                        }
+                    }
+                }
             }
         }
         return Compilation::Stop;

branches/stable/src/librustc_mir/mir_map.rs

@@ -23,7 +23,7 @@ extern crate rustc_front;
 use build;
 use graphviz;
 use pretty;
-use transform::{simplify_cfg, MirPass};
+use transform::*;
 use rustc::dep_graph::DepNode;
 use rustc::mir::repr::Mir;
 use hair::cx::Cx;

branches/stable/src/librustc_mir/transform/erase_regions.rs

@@ -14,9 +14,8 @@
 
 use rustc::middle::ty;
 use rustc::mir::repr::*;
-use rustc::mir::visit::MutVisitor;
-use mir_map::MirMap;
 use transform::MirPass;
+use mir_map::MirMap;
 
 pub fn erase_regions<'tcx>(tcx: &ty::ctxt<'tcx>, mir_map: &mut MirMap<'tcx>) {
     let mut eraser = EraseRegions::new(tcx);
@@ -30,105 +29,196 @@ pub struct EraseRegions<'a, 'tcx: 'a> {
     tcx: &'a ty::ctxt<'tcx>,
 }
 
+impl<'a, 'tcx> MirPass<'tcx> for EraseRegions<'a, 'tcx> {
+
+    fn run_on_mir(&mut self, mir: &mut Mir<'tcx>) {
+
+        for basic_block in &mut mir.basic_blocks {
+            self.erase_regions_basic_block(basic_block);
+        }
+
+        self.erase_regions_return_ty(&mut mir.return_ty);
+
+        self.erase_regions_tys(mir.var_decls.iter_mut().map(|d| &mut d.ty));
+        self.erase_regions_tys(mir.arg_decls.iter_mut().map(|d| &mut d.ty));
+        self.erase_regions_tys(mir.temp_decls.iter_mut().map(|d| &mut d.ty));
+    }
+}
+
 impl<'a, 'tcx> EraseRegions<'a, 'tcx> {
+
     pub fn new(tcx: &'a ty::ctxt<'tcx>) -> EraseRegions<'a, 'tcx> {
         EraseRegions {
             tcx: tcx
         }
     }
 
-    fn erase_regions_return_ty(&mut self, fn_output: &mut ty::FnOutput<'tcx>) {
-        match *fn_output {
-            ty::FnConverging(ref mut ty) => {
-                *ty = self.tcx.erase_regions(ty);
-            },
-            ty::FnDiverging => {}
+    fn erase_regions_basic_block(&mut self,
+                                 basic_block: &mut BasicBlockData<'tcx>) {
+        for statement in &mut basic_block.statements {
+            self.erase_regions_statement(statement);
         }
-    }
-
-    fn erase_regions_tys<'b, T>(&mut self, tys: T)
-        where T: Iterator<Item = &'b mut ty::Ty<'tcx>>,
-              'tcx: 'b
-    {
-        for ty in tys {
-            *ty = self.tcx.erase_regions(ty);
-        }
-    }
-}
 
-impl<'a, 'tcx> MirPass<'tcx> for EraseRegions<'a, 'tcx> {
-    fn run_on_mir(&mut self, mir: &mut Mir<'tcx>) {
-        self.visit_mir(mir);
+        self.erase_regions_terminator(basic_block.terminator_mut());
     }
-}
 
-impl<'a, 'tcx> MutVisitor<'tcx> for EraseRegions<'a, 'tcx> {
-    fn visit_mir(&mut self, mir: &mut Mir<'tcx>) {
-        self.erase_regions_return_ty(&mut mir.return_ty);
-        self.erase_regions_tys(mir.var_decls.iter_mut().map(|d| &mut d.ty));
-        self.erase_regions_tys(mir.arg_decls.iter_mut().map(|d| &mut d.ty));
-        self.erase_regions_tys(mir.temp_decls.iter_mut().map(|d| &mut d.ty));
-        self.super_mir(mir);
+    fn erase_regions_statement(&mut self,
+                               statement: &mut Statement<'tcx>) {
+        match statement.kind {
+            StatementKind::Assign(ref mut lvalue, ref mut rvalue) => {
+                self.erase_regions_lvalue(lvalue);
+                self.erase_regions_rvalue(rvalue);
+            }
+        }
     }
 
-    fn visit_terminator(&mut self, bb: BasicBlock, terminator: &mut Terminator<'tcx>) {
+    fn erase_regions_terminator(&mut self,
+                                terminator: &mut Terminator<'tcx>) {
         match *terminator {
             Terminator::Goto { .. } |
             Terminator::Resume |
-            Terminator::Return |
-            Terminator::If { .. } |
-            Terminator::Switch { .. } |
-            Terminator::Drop { .. } |
-            Terminator::Call { .. } => {
+            Terminator::Return => {
                 /* nothing to do */
-            },
-            Terminator::SwitchInt { ref mut switch_ty, .. } => {
+            }
+            Terminator::If { ref mut cond, .. } => {
+                self.erase_regions_operand(cond);
+            }
+            Terminator::Switch { ref mut discr, .. } => {
+                self.erase_regions_lvalue(discr);
+            }
+            Terminator::SwitchInt { ref mut discr, ref mut switch_ty, .. } => {
+                self.erase_regions_lvalue(discr);
                 *switch_ty = self.tcx.erase_regions(switch_ty);
             },
+            Terminator::Drop { ref mut value, .. } => {
+                self.erase_regions_lvalue(value);
+            }
+            Terminator::Call { ref mut func, ref mut args, ref mut destination, .. } => {
+                if let Some((ref mut destination, _)) = *destination {
+                    self.erase_regions_lvalue(destination);
+                }
+                self.erase_regions_operand(func);
+                for arg in &mut *args {
+                    self.erase_regions_operand(arg);
+                }
+            }
         }
-        self.super_terminator(bb, terminator);
     }
 
-    fn visit_rvalue(&mut self, rvalue: &mut Rvalue<'tcx>) {
-        match *rvalue {
-            Rvalue::Use(_) |
-            Rvalue::Len(_) |
-            Rvalue::BinaryOp(_, _, _) |
-            Rvalue::UnaryOp(_, _) |
-            Rvalue::Slice { input: _, from_start: _, from_end: _ } |
-            Rvalue::InlineAsm(_) => {},
-
-            Rvalue::Repeat(_, ref mut value) => value.ty = self.tcx.erase_regions(&value.ty),
-            Rvalue::Ref(ref mut region, _, _) => *region = ty::ReStatic,
-            Rvalue::Cast(_, _, ref mut ty) => *ty = self.tcx.erase_regions(ty),
-            Rvalue::Box(ref mut ty) => *ty = self.tcx.erase_regions(ty),
+    fn erase_regions_operand(&mut self, operand: &mut Operand<'tcx>) {
+        match *operand {
+            Operand::Consume(ref mut lvalue) => {
+                self.erase_regions_lvalue(lvalue);
+            }
+            Operand::Constant(ref mut constant) => {
+                self.erase_regions_constant(constant);
+            }
+        }
+    }
 
+    fn erase_regions_lvalue(&mut self, lvalue: &mut Lvalue<'tcx>) {
+        match *lvalue {
+            Lvalue::Var(_)        |
+            Lvalue::Temp(_)       |
+            Lvalue::Arg(_)        |
+            Lvalue::Static(_)     |
+            Lvalue::ReturnPointer => {}
+            Lvalue::Projection(ref mut lvalue_projection) => {
+                self.erase_regions_lvalue(&mut lvalue_projection.base);
+                match lvalue_projection.elem {
+                    ProjectionElem::Deref              |
+                    ProjectionElem::Field(_)           |
+                    ProjectionElem::Downcast(..)       |
+                    ProjectionElem::ConstantIndex {..} => { /* nothing to do */ }
+                    ProjectionElem::Index(ref mut index) => {
+                        self.erase_regions_operand(index);
+                    }
+                }
+            }
+        }
+    }
 
-            Rvalue::Aggregate(AggregateKind::Vec, _) |
-            Rvalue::Aggregate(AggregateKind::Tuple, _) => {},
-            Rvalue::Aggregate(AggregateKind::Adt(_, _, ref mut substs), _) =>
-                *substs = self.tcx.mk_substs(self.tcx.erase_regions(*substs)),
-            Rvalue::Aggregate(AggregateKind::Closure(def_id, ref mut closure_substs), _) => {
-                let cloned = Box::new(closure_substs.clone());
-                let ty = self.tcx.mk_closure_from_closure_substs(def_id, cloned);
-                let erased = self.tcx.erase_regions(&ty);
-                *closure_substs = match erased.sty {
-                    ty::TyClosure(_, ref closure_substs) => &*closure_substs,
-                    _ => unreachable!()
-                };
+    fn erase_regions_rvalue(&mut self, rvalue: &mut Rvalue<'tcx>) {
+        match *rvalue {
+            Rvalue::Use(ref mut operand) => {
+                self.erase_regions_operand(operand)
+            }
+            Rvalue::Repeat(ref mut operand, ref mut value) => {
+                self.erase_regions_operand(operand);
+                value.ty = self.tcx.erase_regions(&value.ty);
+            }
+            Rvalue::Ref(ref mut region, _, ref mut lvalue) => {
+                *region = ty::ReStatic;
+                self.erase_regions_lvalue(lvalue);
+            }
+            Rvalue::Len(ref mut lvalue) => self.erase_regions_lvalue(lvalue),
+            Rvalue::Cast(_, ref mut operand, ref mut ty) => {
+                self.erase_regions_operand(operand);
+                *ty = self.tcx.erase_regions(ty);
+            }
+            Rvalue::BinaryOp(_, ref mut operand1, ref mut operand2) => {
+                self.erase_regions_operand(operand1);
+                self.erase_regions_operand(operand2);
+            }
+            Rvalue::UnaryOp(_, ref mut operand) => {
+                self.erase_regions_operand(operand);
             }
+            Rvalue::Box(ref mut ty) => *ty = self.tcx.erase_regions(ty),
+            Rvalue::Aggregate(ref mut aggregate_kind, ref mut operands) => {
+                match *aggregate_kind {
+                    AggregateKind::Vec   |
+                    AggregateKind::Tuple => {},
+                    AggregateKind::Adt(_, _, ref mut substs) => {
+                        let erased = self.tcx.erase_regions(*substs);
+                        *substs = self.tcx.mk_substs(erased);
+                    }
+                    AggregateKind::Closure(def_id, ref mut closure_substs) => {
+                        let cloned = Box::new(closure_substs.clone());
+                        let ty = self.tcx.mk_closure_from_closure_substs(def_id,
+                                                                         cloned);
+                        let erased = self.tcx.erase_regions(&ty);
+                        *closure_substs = match erased.sty {
+                            ty::TyClosure(_, ref closure_substs) => &*closure_substs,
+                            _ => unreachable!()
+                        };
+                    }
+                }
+                for operand in &mut *operands {
+                    self.erase_regions_operand(operand);
+                }
+            }
+            Rvalue::Slice { ref mut input, .. } => {
+                self.erase_regions_lvalue(input);
+            }
+            Rvalue::InlineAsm(_) => {},
         }
-        self.super_rvalue(rvalue);
     }
 
-    fn visit_constant(&mut self, constant: &mut Constant<'tcx>) {
+    fn erase_regions_constant(&mut self, constant: &mut Constant<'tcx>) {
         constant.ty = self.tcx.erase_regions(&constant.ty);
         match constant.literal {
             Literal::Item { ref mut substs, .. } => {
                 *substs = self.tcx.mk_substs(self.tcx.erase_regions(substs));
             }
             Literal::Value { .. } => { /* nothing to do */ }
         }
-        self.super_constant(constant);
+    }
+
+    fn erase_regions_return_ty(&mut self, fn_output: &mut ty::FnOutput<'tcx>) {
+        match *fn_output {
+            ty::FnConverging(ref mut ty) => {
+                *ty = self.tcx.erase_regions(ty);
+            },
+            ty::FnDiverging => {}
+        }
+    }
+
+    fn erase_regions_tys<'b, T>(&mut self, tys: T)
+        where T: Iterator<Item = &'b mut ty::Ty<'tcx>>,
+              'tcx: 'b
+    {
+        for ty in tys {
+            *ty = self.tcx.erase_regions(ty);
+        }
     }
 }

branches/stable/src/test/run-make/print-cfg/Makefile

@@ -0,0 +1,15 @@
+-include ../tools.mk
+
+all: default
+	$(RUSTC) --target x86_64-pc-windows-gnu --print cfg | grep windows
+	$(RUSTC) --target x86_64-pc-windows-gnu --print cfg | grep x86_64
+	$(RUSTC) --target i686-pc-windows-msvc --print cfg | grep msvc
+	$(RUSTC) --target i686-apple-darwin --print cfg | grep macos
+
+ifdef IS_WINDOWS
+default:
+	$(RUSTC) --print cfg | grep windows
+else
+default:
+	$(RUSTC) --print cfg | grep unix
+endif