Rollup of 4 pull requests

src/librustc/arena.rs

@@ -23,9 +23,9 @@ macro_rules! arena_types {
             [] generics: rustc::ty::Generics,
             [] trait_def: rustc::ty::TraitDef,
             [] adt_def: rustc::ty::AdtDef,
-            [] steal_mir: rustc::ty::steal::Steal<rustc::mir::Body<$tcx>>,
+            [] steal_mir: rustc_data_structures::steal::Steal<rustc::mir::Body<$tcx>>,
             [] mir: rustc::mir::Body<$tcx>,
-            [] steal_promoted: rustc::ty::steal::Steal<
+            [] steal_promoted: rustc_data_structures::steal::Steal<
                 rustc_index::vec::IndexVec<
                     rustc::mir::Promoted,
                     rustc::mir::Body<$tcx>

src/librustc/hir/lowering.rs

@@ -2079,6 +2079,7 @@ impl<'a> LoweringContext<'a> {
             span: l.span,
             attrs: l.attrs.clone(),
             source: hir::LocalSource::Normal,
+            interp_tag: l.interp_tag.clone(),
         }, ids)
     }
 
@@ -3048,6 +3049,7 @@ impl<'a> LoweringContext<'a> {
             source,
             span,
             ty: None,
+            interp_tag: None,
         };
         self.stmt(span, hir::StmtKind::Local(P(local)))
     }

src/librustc/hir/lowering/expr.rs

@@ -392,32 +392,49 @@ impl LoweringContext<'_> {
         )
     }
 
+    /// Desugar `try { <stmts>; <expr> }` into `{ <stmts>; ::std::ops::Try::from_ok(<expr>) }`,
+    /// `try { <stmts>; }` into `{ <stmts>; ::std::ops::Try::from_ok(()) }`
+    /// and save the block id to use it as a break target for desugaring of the `?` operator.
     fn lower_expr_try_block(&mut self, body: &Block) -> hir::ExprKind {
         self.with_catch_scope(body.id, |this| {
-            let unstable_span = this.mark_span_with_reason(
+            let mut block = this.lower_block(body, true).into_inner();
+
+            let try_span = this.mark_span_with_reason(
                 DesugaringKind::TryBlock,
                 body.span,
                 this.allow_try_trait.clone(),
             );
-            let mut block = this.lower_block(body, true).into_inner();
-            let tail = block.expr.take().map_or_else(
-                || this.expr_unit(this.sess.source_map().end_point(unstable_span)),
+
+            // Final expression of the block (if present) or `()` with span at the end of block
+            let tail_expr = block.expr.take().map_or_else(
+                || this.expr_unit(this.sess.source_map().end_point(try_span)),
                 |x: P<hir::Expr>| x.into_inner(),
             );
-            block.expr = Some(this.wrap_in_try_constructor(sym::from_ok, tail, unstable_span));
+
+            let ok_wrapped_span = this.mark_span_with_reason(
+                DesugaringKind::TryBlock,
+                tail_expr.span,
+                None
+            );
+
+            // `::std::ops::Try::from_ok($tail_expr)`
+            block.expr = Some(this.wrap_in_try_constructor(
+                sym::from_ok, try_span, tail_expr, ok_wrapped_span));
+
             hir::ExprKind::Block(P(block), None)
         })
     }
 
     fn wrap_in_try_constructor(
         &mut self,
         method: Symbol,
-        e: hir::Expr,
-        unstable_span: Span,
+        method_span: Span,
+        expr: hir::Expr,
+        overall_span: Span,
     ) -> P<hir::Expr> {
         let path = &[sym::ops, sym::Try, method];
-        let from_err = P(self.expr_std_path(unstable_span, path, None, ThinVec::new()));
-        P(self.expr_call(e.span, from_err, hir_vec![e]))
+        let constructor = P(self.expr_std_path(method_span, path, None, ThinVec::new()));
+        P(self.expr_call(overall_span, constructor, hir_vec![expr]))
     }
 
     fn lower_arm(&mut self, arm: &Arm) -> hir::Arm {
@@ -1244,7 +1261,7 @@ impl LoweringContext<'_> {
                 self.expr_call_std_path(try_span, from_path, hir_vec![err_expr])
             };
             let from_err_expr =
-                self.wrap_in_try_constructor(sym::from_error, from_expr, unstable_span);
+                self.wrap_in_try_constructor(sym::from_error, unstable_span, from_expr, try_span);
             let thin_attrs = ThinVec::from(attrs);
             let catch_scope = self.catch_scopes.last().map(|x| *x);
             let ret_expr = if let Some(catch_node) = catch_scope {

src/librustc/hir/mod.rs

@@ -861,7 +861,7 @@ pub struct Block {
     pub span: Span,
     /// If true, then there may exist `break 'a` values that aim to
     /// break out of this block early.
-    /// Used by `'label: {}` blocks and by `catch` statements.
+    /// Used by `'label: {}` blocks and by `try {}` blocks.
     pub targeted_by_break: bool,
 }
 
@@ -1273,6 +1273,8 @@ pub struct Local {
     /// Can be `ForLoopDesugar` if the `let` statement is part of a `for` loop
     /// desugaring. Otherwise will be `Normal`.
     pub source: LocalSource,
+    /// See comment on `syntax::ast::Local`.
+    pub interp_tag: Option<ast::LocalInterpTag>,
 }
 
 /// Represents a single arm of a `match` expression, e.g.

src/librustc/ich/impls_hir.rs

@@ -392,3 +392,14 @@ impl<'hir> HashStable<StableHashingContext<'hir>> for attr::OptimizeAttr {
         mem::discriminant(self).hash_stable(hcx, hasher);
     }
 }
+
+impl_stable_hash_for!(enum ast::LocalInterpState {
+    Uninitialized,
+    Set,
+    Moved,
+});
+
+impl_stable_hash_for!(struct ast::LocalInterpTag {
+    id,
+    state,
+});

src/librustc/ich/impls_ty.rs

@@ -1,14 +1,15 @@
 //! This module contains `HashStable` implementations for various data types
-//! from rustc::ty in no particular order.
+//! from `rustc::ty` in no particular order.
 
 use crate::ich::{Fingerprint, StableHashingContext, NodeIdHashingMode};
+use crate::middle::region;
+use crate::mir;
+use crate::ty;
+
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::stable_hasher::{HashStable, ToStableHashKey, StableHasher};
 use std::cell::RefCell;
 use std::mem;
-use crate::middle::region;
-use crate::ty;
-use crate::mir;
 
 impl<'a, 'tcx, T> HashStable<StableHashingContext<'a>> for &'tcx ty::List<T>
 where
@@ -197,15 +198,6 @@ impl<'a> HashStable<StableHashingContext<'a>> for ty::FloatVid {
     }
 }
 
-impl<'a, T> HashStable<StableHashingContext<'a>> for ty::steal::Steal<T>
-where
-    T: HashStable<StableHashingContext<'a>>,
-{
-    fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) {
-        self.borrow().hash_stable(hcx, hasher);
-    }
-}
-
 impl<'a> HashStable<StableHashingContext<'a>>
 for crate::middle::privacy::AccessLevels {
     fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) {

src/librustc/query/mod.rs

@@ -1120,8 +1120,7 @@ rustc_queries! {
         }
 
         // Get an estimate of the size of an InstanceDef based on its MIR for CGU partitioning.
-        query instance_def_size_estimate(def: ty::InstanceDef<'tcx>)
-            -> usize {
+        query instance_def_size_estimate(def: ty::InstanceDef<'tcx>) -> usize {
             no_force
             desc { |tcx| "estimating size for `{}`", tcx.def_path_str(def.def_id()) }
         }
@@ -1130,5 +1129,10 @@ rustc_queries! {
             eval_always
             desc { "looking up enabled feature gates" }
         }
+
+        query interp_user_fn(_: CrateNum) -> DefId {
+            eval_always
+            desc { "locating interpreter user fn in HIR" }
+        }
     }
 }

src/librustc/session/config.rs

@@ -391,6 +391,7 @@ top_level_options!(
         // can influence whether overflow checks are done or not.
         debug_assertions: bool [TRACKED],
         debuginfo: DebugInfo [TRACKED],
+        interp_mode: bool [TRACKED],
         lint_opts: Vec<(String, lint::Level)> [TRACKED],
         lint_cap: Option<lint::Level> [TRACKED],
         describe_lints: bool [UNTRACKED],
@@ -599,6 +600,7 @@ impl Default for Options {
             crate_types: Vec::new(),
             optimize: OptLevel::No,
             debuginfo: DebugInfo::None,
+            interp_mode: false,
             lint_opts: Vec::new(),
             lint_cap: None,
             describe_lints: false,
@@ -2467,6 +2469,7 @@ pub fn build_session_options_and_crate_config(
             crate_types,
             optimize: opt_level,
             debuginfo,
+            interp_mode: false,
             lint_opts,
             lint_cap,
             describe_lints,

src/librustc/ty/context.rs

@@ -38,7 +38,6 @@ use crate::ty::{InferConst, ParamConst};
 use crate::ty::GenericParamDefKind;
 use crate::ty::layout::{LayoutDetails, TargetDataLayout, VariantIdx};
 use crate::ty::query;
-use crate::ty::steal::Steal;
 use crate::ty::subst::{UserSubsts, GenericArgKind};
 use crate::ty::{BoundVar, BindingMode};
 use crate::ty::CanonicalPolyFnSig;
@@ -49,12 +48,13 @@ use crate::util::nodemap::{FxHashMap, FxHashSet};
 use errors::DiagnosticBuilder;
 use arena::SyncDroplessArena;
 use smallvec::SmallVec;
+use rustc_index::vec::{Idx, IndexVec};
 use rustc_data_structures::stable_hasher::{
     HashStable, StableHasher, StableVec, hash_stable_hashmap,
 };
-use rustc_index::vec::{Idx, IndexVec};
 use rustc_data_structures::sharded::ShardedHashMap;
 use rustc_data_structures::sync::{Lrc, Lock, WorkerLocal};
+use rustc_data_structures::steal::Steal;
 use std::any::Any;
 use std::borrow::Borrow;
 use std::cmp::Ordering;
@@ -2894,6 +2894,44 @@ fn ptr_eq<T, U>(t: *const T, u: *const U) -> bool {
     t as *const () == u as *const ()
 }
 
+/// In interpreter mode, locates the `DefId` of the user fn (a closure marked by an attribute named
+/// `rustc_interp_user_fn`) by visiting the local crate's HIR.
+fn find_interp_user_fn(tcx: TyCtxt<'_>) -> DefId {
+    use hir::intravisit::{self, Visitor, NestedVisitorMap};
+
+    struct InterpUserFnVisitor<'tcx> {
+        tcx: TyCtxt<'tcx>,
+        def_id: Option<DefId>,
+    }
+
+    impl<'tcx> Visitor<'tcx> for InterpUserFnVisitor<'tcx> {
+        fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
+            NestedVisitorMap::OnlyBodies(&self.tcx.hir())
+        }
+
+        fn visit_expr(&mut self, ex: &'tcx hir::Expr) {
+            if syntax::attr::contains_name(&ex.attrs, sym::rustc_interp_user_fn) {
+                self.def_id = Some(self.tcx.hir().local_def_id(ex.hir_id));
+                return;
+            }
+
+            intravisit::walk_expr(self, ex);
+        }
+    }
+
+    let mut visitor = InterpUserFnVisitor {
+        tcx,
+        def_id: None,
+    };
+    tcx.hir().krate().visit_all_item_likes(&mut visitor.as_deep_visitor());
+    visitor.def_id
+        .unwrap_or_else(|| tcx.sess.fatal(&format!(
+            "could not find interpreter user fn in HIR; it should be a closure expression \
+             marked with the `#[{}]` attribute",
+            sym::rustc_interp_user_fn
+        )))
+}
+
 pub fn provide(providers: &mut ty::query::Providers<'_>) {
     providers.in_scope_traits_map = |tcx, id| tcx.gcx.trait_map.get(&id);
     providers.module_exports = |tcx, id| tcx.gcx.export_map.get(&id).map(|v| &v[..]);
@@ -2971,4 +3009,8 @@ pub fn provide(providers: &mut ty::query::Providers<'_>) {
         assert_eq!(cnum, LOCAL_CRATE);
         attr::contains_name(tcx.hir().krate_attrs(), sym::compiler_builtins)
     };
+    providers.interp_user_fn = |tcx, cnum| {
+        assert_eq!(cnum, LOCAL_CRATE);
+        find_interp_user_fn(tcx)
+    };
 }

src/librustc/ty/mod.rs

@@ -105,7 +105,6 @@ pub mod outlives;
 pub mod print;
 pub mod query;
 pub mod relate;
-pub mod steal;
 pub mod subst;
 pub mod trait_def;
 pub mod walk;

src/librustc/ty/query/mod.rs

@@ -34,7 +34,7 @@ use crate::traits::query::outlives_bounds::OutlivesBound;
 use crate::traits::specialization_graph;
 use crate::traits::Clauses;
 use crate::ty::{self, CrateInherentImpls, ParamEnvAnd, Ty, TyCtxt, AdtSizedConstraint};
-use crate::ty::steal::Steal;
+use rustc_data_structures::steal::Steal;
 use crate::ty::util::NeedsDrop;
 use crate::ty::subst::SubstsRef;
 use crate::util::nodemap::{DefIdSet, DefIdMap, ItemLocalSet};

src/librustc_data_structures/lib.rs

@@ -94,6 +94,7 @@ pub use ena::unify;
 pub mod vec_linked_list;
 pub mod work_queue;
 pub mod fingerprint;
+pub mod steal;
 
 pub struct OnDrop<F: Fn()>(pub F);
 

src/librustc/ty/steal.rs → src/librustc_data_structures/steal.rs

@@ -1,7 +1,8 @@
-use rustc_data_structures::sync::{RwLock, ReadGuard, MappedReadGuard};
+use crate::stable_hasher::{StableHasher, HashStable};
+use crate::sync::{RwLock, ReadGuard, MappedReadGuard};
 
 /// The `Steal` struct is intended to used as the value for a query.
-/// Specifically, we sometimes have queries (*cough* MIR *cough*)
+/// Specifically, we sometimes have queries (in particular, for MIR)
 /// where we create a large, complex value that we want to iteratively
 /// update (e.g., optimize). We could clone the value for each
 /// optimization, but that'd be expensive. And yet we don't just want
@@ -26,21 +27,28 @@ pub struct Steal<T> {
 
 impl<T> Steal<T> {
     pub fn new(value: T) -> Self {
-        Steal {
+        Self {
             value: RwLock::new(Some(value))
         }
     }
 
     pub fn borrow(&self) -> MappedReadGuard<'_, T> {
         ReadGuard::map(self.value.borrow(), |opt| match *opt {
-            None => bug!("attempted to read from stolen value"),
+            None => panic!("attempted to read from stolen value"),
             Some(ref v) => v
         })
     }
 
     pub fn steal(&self) -> T {
-        let value_ref = &mut *self.value.try_write().expect("stealing value which is locked");
+        let value_ref = &mut *self.value.try_write()
+            .expect("stealing value that is locked");
         let value = value_ref.take();
         value.expect("attempt to read from stolen value")
     }
 }
+
+impl<T: HashStable<CTX>, CTX> HashStable<CTX> for Steal<T> {
+    fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher) {
+        self.borrow().hash_stable(hcx, hasher);
+    }
+}