Don't run the deaggregator on const fns

The deaggregator will generate assignments that aren't allowed in const
expressions.

This also refactors `is_const_fn` into a method on `TyCtxt`.

Author: Aatch

src/librustc/ty/mod.rs

@@ -2973,6 +2973,27 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
                                                                             autoderefs))
     }
 
+    /// Checks if the given def is a const fn
+    pub fn is_const_fn(self, def_id: DefId) -> bool {
+        use hir::intravisit::FnKind;
+        use hir::map::blocks::FnLikeNode;
+
+        if let Some(node_id) = self.map.as_local_node_id(def_id) {
+            let fn_like = FnLikeNode::from_node(self.map.get(node_id));
+            match fn_like.map(|f| f.kind()) {
+                Some(FnKind::ItemFn(_, _, _, c, ..)) => {
+                    c == hir::Constness::Const
+                }
+                Some(FnKind::Method(_, m, ..)) => {
+                    m.constness == hir::Constness::Const
+                }
+                _ => false
+            }
+        } else {
+            self.sess.cstore.is_const_fn(def_id)
+        }
+    }
+
     pub fn upvar_capture(self, upvar_id: ty::UpvarId) -> Option<ty::UpvarCapture<'tcx>> {
         Some(self.tables.borrow().upvar_capture_map.get(&upvar_id).unwrap().clone())
     }

src/librustc_mir/transform/deaggregator.rs

@@ -22,7 +22,8 @@ impl<'tcx> MirPass<'tcx> for Deaggregator {
     fn run_pass<'a>(&mut self, tcx: TyCtxt<'a, 'tcx, 'tcx>,
                     source: MirSource, mir: &mut Mir<'tcx>) {
         let node_id = source.item_id();
-        let node_path = tcx.item_path_str(tcx.map.local_def_id(node_id));
+        let def_id = tcx.map.local_def_id(node_id);
+        let node_path = tcx.item_path_str(def_id);
         debug!("running on: {:?}", node_path);
         // we only run when mir_opt_level > 1
         match tcx.sess.opts.debugging_opts.mir_opt_level {
@@ -37,6 +38,9 @@ impl<'tcx> MirPass<'tcx> for Deaggregator {
         // In fact, we might not want to trigger in other cases.
         // Ex: when we could use SROA.  See issue #35259
 
+        // Don't deaggregate in const fns
+        if tcx.is_const_fn(def_id) { return; }
+
         let mut curr: usize = 0;
         for bb in mir.basic_blocks_mut() {
             let idx = match get_aggregate_statement_index(curr, &bb.statements) {

src/librustc_mir/transform/qualify_consts.rs

@@ -20,8 +20,6 @@ use rustc::dep_graph::DepNode;
 use rustc::hir;
 use rustc::hir::map as hir_map;
 use rustc::hir::def_id::DefId;
-use rustc::hir::intravisit::FnKind;
-use rustc::hir::map::blocks::FnLikeNode;
 use rustc::traits::{self, Reveal};
 use rustc::ty::{self, TyCtxt, Ty};
 use rustc::ty::cast::CastTy;
@@ -116,23 +114,6 @@ impl fmt::Display for Mode {
     }
 }
 
-fn is_const_fn(tcx: TyCtxt, def_id: DefId) -> bool {
-    if let Some(node_id) = tcx.map.as_local_node_id(def_id) {
-        let fn_like = FnLikeNode::from_node(tcx.map.get(node_id));
-        match fn_like.map(|f| f.kind()) {
-            Some(FnKind::ItemFn(_, _, _, c, ..)) => {
-                c == hir::Constness::Const
-            }
-            Some(FnKind::Method(_, m, ..)) => {
-                m.constness == hir::Constness::Const
-            }
-            _ => false
-        }
-    } else {
-        tcx.sess.cstore.is_const_fn(def_id)
-    }
-}
-
 struct Qualifier<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
     mode: Mode,
     span: Span,
@@ -778,7 +759,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Qualifier<'a, 'tcx, 'tcx> {
                 ty::TyFnDef(def_id, _, f) => {
                     (f.abi == Abi::PlatformIntrinsic &&
                      self.tcx.item_name(def_id).as_str().starts_with("simd_shuffle"),
-                     is_const_fn(self.tcx, def_id))
+                     self.tcx.is_const_fn(def_id))
                 }
                 _ => (false, false)
             };
@@ -997,7 +978,7 @@ impl<'tcx> MirMapPass<'tcx> for QualifyAndPromoteConstants {
             let src = MirSource::from_node(tcx, id);
             let mode = match src {
                 MirSource::Fn(_) => {
-                    if is_const_fn(tcx, def_id) {
+                    if tcx.is_const_fn(def_id) {
                         Mode::ConstFn
                     } else {
                         Mode::Fn