Rollup of 8 pull requests

src/liballoc/lib.rs

@@ -85,6 +85,7 @@
 #![feature(const_generic_impls_guard)]
 #![feature(const_generics)]
 #![feature(const_in_array_repeat_expressions)]
+#![feature(const_if_match)]
 #![feature(cow_is_borrowed)]
 #![feature(dispatch_from_dyn)]
 #![feature(core_intrinsics)]

src/liballoc/raw_vec.rs

@@ -52,15 +52,12 @@ impl<T, A: Alloc> RawVec<T, A> {
     /// Like `new`, but parameterized over the choice of allocator for
     /// the returned `RawVec`.
     pub const fn new_in(a: A) -> Self {
-        // `!0` is `usize::MAX`. This branch should be stripped at compile time.
-        // FIXME(mark-i-m): use this line when `if`s are allowed in `const`:
-        //let cap = if mem::size_of::<T>() == 0 { !0 } else { 0 };
+        let cap = if mem::size_of::<T>() == 0 { core::usize::MAX } else { 0 };
 
         // `Unique::empty()` doubles as "unallocated" and "zero-sized allocation".
         RawVec {
             ptr: Unique::empty(),
-            // FIXME(mark-i-m): use `cap` when ifs are allowed in const
-            cap: [0, !0][(mem::size_of::<T>() == 0) as usize],
+            cap,
             a,
         }
     }
@@ -132,19 +129,7 @@ impl<T> RawVec<T, Global> {
     /// `RawVec` with capacity `usize::MAX`. Useful for implementing
     /// delayed allocation.
     pub const fn new() -> Self {
-        // FIXME(Centril): Reintegrate this with `fn new_in` when we can.
-
-        // `!0` is `usize::MAX`. This branch should be stripped at compile time.
-        // FIXME(mark-i-m): use this line when `if`s are allowed in `const`:
-        //let cap = if mem::size_of::<T>() == 0 { !0 } else { 0 };
-
-        // `Unique::empty()` doubles as "unallocated" and "zero-sized allocation".
-        RawVec {
-            ptr: Unique::empty(),
-            // FIXME(mark-i-m): use `cap` when ifs are allowed in const
-            cap: [0, !0][(mem::size_of::<T>() == 0) as usize],
-            a: Global,
-        }
+        Self::new_in(Global)
     }
 
     /// Creates a `RawVec` (on the system heap) with exactly the

src/librustc/infer/error_reporting/need_type_info.rs

@@ -3,7 +3,7 @@ use crate::hir::{self, Body, FunctionRetTy, Expr, ExprKind, HirId, Local, Pat};
 use crate::hir::intravisit::{self, Visitor, NestedVisitorMap};
 use crate::infer::InferCtxt;
 use crate::infer::type_variable::TypeVariableOriginKind;
-use crate::ty::{self, Ty, Infer, TyVar};
+use crate::ty::{self, Ty, Infer, TyVar, DefIdTree};
 use crate::ty::print::Print;
 use syntax::source_map::DesugaringKind;
 use syntax::symbol::kw;
@@ -117,6 +117,8 @@ fn closure_return_type_suggestion(
     descr: &str,
     name: &str,
     ret: &str,
+    parent_name: Option<String>,
+    parent_descr: Option<&str>,
 ) {
     let (arrow, post) = match output {
         FunctionRetTy::DefaultReturn(_) => ("-> ", " "),
@@ -138,7 +140,12 @@ fn closure_return_type_suggestion(
         suggestion,
         Applicability::HasPlaceholders,
     );
-    err.span_label(span, InferCtxt::missing_type_msg(&name, &descr));
+    err.span_label(span, InferCtxt::missing_type_msg(
+        &name,
+        &descr,
+        parent_name,
+        parent_descr
+    ));
 }
 
 /// Given a closure signature, return a `String` containing a list of all its argument types.
@@ -177,16 +184,31 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         &self,
         ty: Ty<'tcx>,
         highlight: Option<ty::print::RegionHighlightMode>,
-    ) -> (String, Option<Span>, Cow<'static, str>) {
+    ) -> (String, Option<Span>, Cow<'static, str>, Option<String>, Option<&'static str>) {
         if let ty::Infer(ty::TyVar(ty_vid)) = ty.kind {
             let ty_vars = self.type_variables.borrow();
             let var_origin = ty_vars.var_origin(ty_vid);
-            if let TypeVariableOriginKind::TypeParameterDefinition(name) = var_origin.kind {
+            if let TypeVariableOriginKind::TypeParameterDefinition(name, def_id) = var_origin.kind {
+                let parent_def_id = def_id.and_then(|def_id| self.tcx.parent(def_id));
+                let (parent_name, parent_desc) = if let Some(parent_def_id) = parent_def_id {
+                    let parent_name = self.tcx.def_key(parent_def_id).disambiguated_data.data
+                        .get_opt_name().map(|parent_symbol| parent_symbol.to_string());
+
+                    let type_parent_desc = self.tcx.def_kind(parent_def_id)
+                        .map(|parent_def_kind| parent_def_kind.descr(parent_def_id));
+
+                    (parent_name, type_parent_desc)
+                } else {
+                    (None, None)
+                };
+
                 if name != kw::SelfUpper {
                     return (
                         name.to_string(),
                         Some(var_origin.span),
                         "type parameter".into(),
+                        parent_name,
+                        parent_desc,
                     );
                 }
             }
@@ -198,7 +220,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
             printer.region_highlight_mode = highlight;
         }
         let _ = ty.print(printer);
-        (s, None, ty.prefix_string())
+        (s, None, ty.prefix_string(), None, None)
     }
 
     pub fn need_type_info_err(
@@ -209,7 +231,8 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         error_code: TypeAnnotationNeeded,
     ) -> DiagnosticBuilder<'tcx> {
         let ty = self.resolve_vars_if_possible(&ty);
-        let (name, name_sp, descr) = self.extract_type_name(&ty, None);
+        let (name, name_sp, descr, parent_name, parent_descr) = self.extract_type_name(&ty, None);
+
 
         let mut local_visitor = FindLocalByTypeVisitor::new(&self, ty, &self.tcx.hir());
         let ty_to_string = |ty: Ty<'tcx>| -> String {
@@ -218,7 +241,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
             let ty_vars = self.type_variables.borrow();
             let getter = move |ty_vid| {
                 let var_origin = ty_vars.var_origin(ty_vid);
-                if let TypeVariableOriginKind::TypeParameterDefinition(name) = var_origin.kind {
+                if let TypeVariableOriginKind::TypeParameterDefinition(name, _) = var_origin.kind {
                     return Some(name.to_string());
                 }
                 None
@@ -317,6 +340,8 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
                             &descr,
                             &name,
                             &ret,
+                            parent_name,
+                            parent_descr,
                         );
                         // We don't want to give the other suggestions when the problem is the
                         // closure return type.
@@ -433,8 +458,12 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         if !err.span.span_labels().iter().any(|span_label| {
                 span_label.label.is_some() && span_label.span == span
             }) && local_visitor.found_arg_pattern.is_none()
-        { // Avoid multiple labels pointing at `span`.
-            err.span_label(span, InferCtxt::missing_type_msg(&name, &descr));
+        {
+            // Avoid multiple labels pointing at `span`.
+            err.span_label(
+                span,
+                InferCtxt::missing_type_msg(&name, &descr, parent_name, parent_descr)
+            );
         }
 
         err
@@ -496,19 +525,42 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         ty: Ty<'tcx>,
     ) -> DiagnosticBuilder<'tcx> {
         let ty = self.resolve_vars_if_possible(&ty);
-        let (name, _, descr) = self.extract_type_name(&ty, None);
+        let (name, _, descr, parent_name, parent_descr) = self.extract_type_name(&ty, None);
+
         let mut err = struct_span_err!(
             self.tcx.sess, span, E0698, "type inside {} must be known in this context", kind,
         );
-        err.span_label(span, InferCtxt::missing_type_msg(&name, &descr));
+        err.span_label(span, InferCtxt::missing_type_msg(
+            &name,
+            &descr,
+            parent_name,
+            parent_descr
+        ));
         err
     }
 
-    fn missing_type_msg(type_name: &str, descr: &str) -> Cow<'static, str>{
+    fn missing_type_msg(
+        type_name: &str,
+        descr: &str,
+        parent_name: Option<String>,
+        parent_descr: Option<&str>,
+    ) -> Cow<'static, str> {
         if type_name == "_" {
             "cannot infer type".into()
         } else {
-            format!("cannot infer type for {} `{}`", descr, type_name).into()
+            let parent_desc = if let Some(parent_name) = parent_name {
+                let parent_type_descr = if let Some(parent_descr) = parent_descr {
+                    format!(" the {}", parent_descr)
+                } else {
+                    "".into()
+                };
+
+                format!(" declared on{} `{}`", parent_type_descr, parent_name)
+            } else {
+                "".to_string()
+            };
+
+            format!("cannot infer type for {} `{}`{}", descr, type_name, parent_desc).into()
         }
     }
 }

src/librustc/infer/mod.rs

@@ -1135,7 +1135,10 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
                     self.universe(),
                     false,
                     TypeVariableOrigin {
-                        kind: TypeVariableOriginKind::TypeParameterDefinition(param.name),
+                        kind: TypeVariableOriginKind::TypeParameterDefinition(
+                            param.name,
+                            Some(param.def_id)
+                        ),
                         span,
                     },
                 );

src/librustc/infer/resolve.rs

@@ -124,7 +124,7 @@ impl<'a, 'tcx> TypeVisitor<'tcx> for UnresolvedTypeFinder<'a, 'tcx> {
                 if let ty::TyVar(ty_vid) = infer_ty {
                     let ty_vars = self.infcx.type_variables.borrow();
                     if let TypeVariableOrigin {
-                        kind: TypeVariableOriginKind::TypeParameterDefinition(_),
+                        kind: TypeVariableOriginKind::TypeParameterDefinition(_, _),
                         span,
                     } = *ty_vars.var_origin(ty_vid)
                     {

src/librustc/infer/type_variable.rs

@@ -1,6 +1,7 @@
 use syntax::symbol::Symbol;
 use syntax_pos::Span;
 use crate::ty::{self, Ty, TyVid};
+use crate::hir::def_id::DefId;
 
 use std::cmp;
 use std::marker::PhantomData;
@@ -49,7 +50,7 @@ pub enum TypeVariableOriginKind {
     MiscVariable,
     NormalizeProjectionType,
     TypeInference,
-    TypeParameterDefinition(Symbol),
+    TypeParameterDefinition(Symbol, Option<DefId>),
 
     /// One of the upvars or closure kind parameters in a `ClosureSubsts`
     /// (before it has been determined).

src/librustc/traits/error_reporting.rs

@@ -2113,7 +2113,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
                     self.var_map.entry(ty).or_insert_with(||
                         infcx.next_ty_var(
                             TypeVariableOrigin {
-                                kind: TypeVariableOriginKind::TypeParameterDefinition(name),
+                                kind: TypeVariableOriginKind::TypeParameterDefinition(name, None),
                                 span: DUMMY_SP,
                             }
                         )

src/librustc/ty/mod.rs

@@ -212,6 +212,17 @@ pub enum AssocKind {
     Type
 }
 
+impl AssocKind {
+    pub fn suggestion_descr(&self) -> &'static str {
+        match self {
+            ty::AssocKind::Method => "method call",
+            ty::AssocKind::Type |
+            ty::AssocKind::OpaqueTy => "associated type",
+            ty::AssocKind::Const => "associated constant",
+        }
+    }
+}
+
 impl AssocItem {
     pub fn def_kind(&self) -> DefKind {
         match self.kind {

src/librustc_codegen_ssa/mir/rvalue.rs

@@ -341,6 +341,13 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                                     llval
                                 }
                             }
+                            (CastTy::Int(_), CastTy::Float) => {
+                                if signed {
+                                    bx.sitofp(llval, ll_t_out)
+                                } else {
+                                    bx.uitofp(llval, ll_t_out)
+                                }
+                            }
                             (CastTy::Ptr(_), CastTy::Ptr(_)) |
                             (CastTy::FnPtr, CastTy::Ptr(_)) |
                             (CastTy::RPtr(_), CastTy::Ptr(_)) =>
@@ -352,8 +359,6 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                                 let usize_llval = bx.intcast(llval, bx.cx().type_isize(), signed);
                                 bx.inttoptr(usize_llval, ll_t_out)
                             }
-                            (CastTy::Int(_), CastTy::Float) =>
-                                cast_int_to_float(&mut bx, signed, llval, ll_t_in, ll_t_out),
                             (CastTy::Float, CastTy::Int(IntTy::I)) =>
                                 cast_float_to_int(&mut bx, true, llval, ll_t_in, ll_t_out),
                             (CastTy::Float, CastTy::Int(_)) =>
@@ -720,40 +725,6 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
     }
 }
 
-fn cast_int_to_float<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
-    bx: &mut Bx,
-    signed: bool,
-    x: Bx::Value,
-    int_ty: Bx::Type,
-    float_ty: Bx::Type
-) -> Bx::Value {
-    // Most integer types, even i128, fit into [-f32::MAX, f32::MAX] after rounding.
-    // It's only u128 -> f32 that can cause overflows (i.e., should yield infinity).
-    // LLVM's uitofp produces undef in those cases, so we manually check for that case.
-    let is_u128_to_f32 = !signed &&
-        bx.cx().int_width(int_ty) == 128 &&
-        bx.cx().float_width(float_ty) == 32;
-    if is_u128_to_f32 {
-        // All inputs greater or equal to (f32::MAX + 0.5 ULP) are rounded to infinity,
-        // and for everything else LLVM's uitofp works just fine.
-        use rustc_apfloat::ieee::Single;
-        const MAX_F32_PLUS_HALF_ULP: u128 = ((1 << (Single::PRECISION + 1)) - 1)
-                                            << (Single::MAX_EXP - Single::PRECISION as i16);
-        let max = bx.cx().const_uint_big(int_ty, MAX_F32_PLUS_HALF_ULP);
-        let overflow = bx.icmp(IntPredicate::IntUGE, x, max);
-        let infinity_bits = bx.cx().const_u32(ieee::Single::INFINITY.to_bits() as u32);
-        let infinity = bx.bitcast(infinity_bits, float_ty);
-        let fp = bx.uitofp(x, float_ty);
-        bx.select(overflow, infinity, fp)
-    } else {
-        if signed {
-            bx.sitofp(x, float_ty)
-        } else {
-            bx.uitofp(x, float_ty)
-        }
-    }
-}
-
 fn cast_float_to_int<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
     bx: &mut Bx,
     signed: bool,

src/librustc_mir/transform/inline.rs

@@ -663,9 +663,9 @@ impl<'a, 'tcx> Integrator<'a, 'tcx> {
 
     fn make_integrate_local(&self, local: &Local) -> Local {
         if *local == RETURN_PLACE {
-            match self.destination.as_local() {
-                Some(l) => return l,
-                ref place => bug!("Return place is {:?}, not local", place),
+            match self.destination.base {
+                PlaceBase::Local(l) => return l,
+                PlaceBase::Static(ref s) => bug!("Return place is {:?}, not local", s),
             }
         }
 
@@ -695,14 +695,24 @@ impl<'a, 'tcx> MutVisitor<'tcx> for Integrator<'a, 'tcx> {
     fn visit_place(
         &mut self,
         place: &mut Place<'tcx>,
-        context: PlaceContext,
-        location: Location,
+        _context: PlaceContext,
+        _location: Location,
     ) {
-        if let Some(RETURN_PLACE) = place.as_local() {
-            // Return pointer; update the place itself
-            *place = self.destination.clone();
-        } else {
-            self.super_place(place, context, location);
+        match &mut place.base {
+            PlaceBase::Static(_) => {},
+            PlaceBase::Local(l) => {
+                // If this is the `RETURN_PLACE`, we need to rebase any projections onto it.
+                let dest_proj_len = self.destination.projection.len();
+                if *l == RETURN_PLACE && dest_proj_len > 0 {
+                    let mut projs = Vec::with_capacity(dest_proj_len + place.projection.len());
+                    projs.extend(self.destination.projection);
+                    projs.extend(place.projection);
+
+                    place.projection = self.tcx.intern_place_elems(&*projs);
+                }
+
+                *l = self.make_integrate_local(l);
+            }
         }
     }