rustc/rustc_mir: Implement RFC 2203.

This commit implements RFC 2203, allowing constants in array repeat
expressions.

Firstly, the check that the array repeat expression implements `Copy` is
removed and re-implemented in `rustc_mir::borrow_check::nll::type_check`
by emitting an error when the MIR contains a `Operand::Move` and the
type does not implement `Copy`.

Next, the `qualify_consts` pass is modified to construct a
`Candidate::Repeat` when it would be correct to promote a array repeat
expression.

Finally, the `promote_consts` pass is modified to promote the candidates
previously identified.

Author: davidtwco

src/librustc/traits/error_reporting.rs

@@ -1564,10 +1564,6 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
                 err.note(&format!("required for the cast to the object type `{}`",
                                   self.ty_to_string(object_ty)));
             }
-            ObligationCauseCode::RepeatVec => {
-                err.note("the `Copy` trait is required because the \
-                          repeated element will be copied");
-            }
             ObligationCauseCode::VariableType(_) => {
                 err.note("all local variables must have a statically known size");
                 if !self.tcx.features().unsized_locals {

src/librustc/traits/mod.rs

@@ -195,8 +195,6 @@ pub enum ObligationCauseCode<'tcx> {
     SizedReturnType,
     /// Yield type must be Sized
     SizedYieldType,
-    /// [T,..n] --> T must be Copy
-    RepeatVec,
 
     /// Types of fields (other than the last, except for packed structs) in a struct must be sized.
     FieldSized { adt_kind: AdtKind, last: bool },

src/librustc/traits/structural_impls.rs

@@ -488,7 +488,6 @@ impl<'a, 'tcx> Lift<'tcx> for traits::ObligationCauseCode<'a> {
             super::SizedArgumentType => Some(super::SizedArgumentType),
             super::SizedReturnType => Some(super::SizedReturnType),
             super::SizedYieldType => Some(super::SizedYieldType),
-            super::RepeatVec => Some(super::RepeatVec),
             super::FieldSized { adt_kind, last } => Some(super::FieldSized { adt_kind, last }),
             super::ConstSized => Some(super::ConstSized),
             super::SharedStatic => Some(super::SharedStatic),

src/librustc_mir/borrow_check/nll/type_check/mod.rs

@@ -501,28 +501,38 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
             // FIXME use place_projection.is_empty() when is available
             if let Place::Base(_) = place {
                 if let PlaceContext::NonMutatingUse(NonMutatingUseContext::Copy) = context {
-                    let tcx = self.tcx();
-                    let trait_ref = ty::TraitRef {
-                        def_id: tcx.lang_items().copy_trait().unwrap(),
-                        substs: tcx.mk_substs_trait(place_ty.ty, &[]),
+                    let is_promoted = match place {
+                        Place::Base(PlaceBase::Static(box Static {
+                            kind: StaticKind::Promoted(_),
+                            ..
+                        })) => true,
+                        _ => false,
                     };
 
-                    // In order to have a Copy operand, the type T of the
-                    // value must be Copy. Note that we prove that T: Copy,
-                    // rather than using the `is_copy_modulo_regions`
-                    // test. This is important because
-                    // `is_copy_modulo_regions` ignores the resulting region
-                    // obligations and assumes they pass. This can result in
-                    // bounds from Copy impls being unsoundly ignored (e.g.,
-                    // #29149). Note that we decide to use Copy before knowing
-                    // whether the bounds fully apply: in effect, the rule is
-                    // that if a value of some type could implement Copy, then
-                    // it must.
-                    self.cx.prove_trait_ref(
-                        trait_ref,
-                        location.to_locations(),
-                        ConstraintCategory::CopyBound,
-                    );
+                    if !is_promoted {
+                        let tcx = self.tcx();
+                        let trait_ref = ty::TraitRef {
+                            def_id: tcx.lang_items().copy_trait().unwrap(),
+                            substs: tcx.mk_substs_trait(place_ty.ty, &[]),
+                        };
+
+                        // In order to have a Copy operand, the type T of the
+                        // value must be Copy. Note that we prove that T: Copy,
+                        // rather than using the `is_copy_modulo_regions`
+                        // test. This is important because
+                        // `is_copy_modulo_regions` ignores the resulting region
+                        // obligations and assumes they pass. This can result in
+                        // bounds from Copy impls being unsoundly ignored (e.g.,
+                        // #29149). Note that we decide to use Copy before knowing
+                        // whether the bounds fully apply: in effect, the rule is
+                        // that if a value of some type could implement Copy, then
+                        // it must.
+                        self.cx.prove_trait_ref(
+                            trait_ref,
+                            location.to_locations(),
+                            ConstraintCategory::CopyBound,
+                        );
+                    }
                 }
             }
 
@@ -1953,18 +1963,32 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             }
 
             Rvalue::Repeat(operand, len) => if *len > 1 {
-                let operand_ty = operand.ty(body, tcx);
-
-                let trait_ref = ty::TraitRef {
-                    def_id: tcx.lang_items().copy_trait().unwrap(),
-                    substs: tcx.mk_substs_trait(operand_ty, &[]),
-                };
-
-                self.prove_trait_ref(
-                    trait_ref,
-                    location.to_locations(),
-                    ConstraintCategory::CopyBound,
-                );
+                if let Operand::Move(_) = operand {
+                    // While this is located in `nll::typeck` this error is not an NLL error, it's
+                    // a required check to make sure that repeated elements implement `Copy`.
+                    let span = body.source_info(location).span;
+                    let ty = operand.ty(body, tcx);
+                    let is_copy = self.infcx.type_is_copy_modulo_regions(self.param_env, ty, span);
+                    if !is_copy {
+                        let copy_path = self.tcx().def_path_str(
+                            self.tcx().lang_items().copy_trait().unwrap());
+                        self.tcx().sess
+                            .struct_span_err(
+                                span,
+                                &format!("repeated expression does not implement `{}`", copy_path),
+                            )
+                            .span_label(span, &format!(
+                                "the trait `{}` is not implemented for `{}`",
+                                copy_path, ty,
+                            ))
+                            .note(&format!(
+                                "the `{}` trait is required because the repeated element will be \
+                                 copied",
+                                 copy_path,
+                            ))
+                            .emit();
+                    }
+                }
             },
 
             Rvalue::NullaryOp(_, ty) => {

src/librustc_mir/transform/promote_consts.rs

@@ -60,6 +60,9 @@ pub enum Candidate {
     /// Borrow of a constant temporary.
     Ref(Location),
 
+    /// Promotion of the `x` in `[x; 32]`.
+    Repeat(Location),
+
     /// Currently applied to function calls where the callee has the unstable
     /// `#[rustc_args_required_const]` attribute as well as the SIMD shuffle
     /// intrinsic. The intrinsic requires the arguments are indeed constant and
@@ -322,6 +325,17 @@ impl<'a, 'tcx> Promoter<'a, 'tcx> {
                         _ => bug!()
                     }
                 }
+                Candidate::Repeat(loc) => {
+                    let ref mut statement = blocks[loc.block].statements[loc.statement_index];
+                    match statement.kind {
+                        StatementKind::Assign(_, box Rvalue::Repeat(ref mut operand, _)) => {
+                            let ty = operand.ty(local_decls, self.tcx);
+                            let span = statement.source_info.span;
+                            mem::replace(operand, Operand::Copy(promoted_place(ty, span)))
+                        }
+                        _ => bug!()
+                    }
+                },
                 Candidate::Argument { bb, index } => {
                     let terminator = blocks[bb].terminator_mut();
                     match terminator.kind {
@@ -380,6 +394,7 @@ pub fn promote_candidates<'tcx>(
 
     for candidate in candidates.into_iter().rev() {
         match candidate {
+            Candidate::Repeat(Location { block, statement_index }) |
             Candidate::Ref(Location { block, statement_index }) => {
                 match body[block].statements[statement_index].kind {
                     StatementKind::Assign(Place::Base(PlaceBase::Local(local)), _) => {