Auto merge of #61210 - Centril:rollup-ofr6h5b, r=Centril

Rollup of 4 pull requests

Successful merges:

 - #61077 (Don't arena-allocate static symbols.)
 - #61102 (Move path for iterate)
 - #61120 (Make eval_place iterate instead of recurse)
 - #61205 (docs: fix typo #61197)

Failed merges:

r? @ghost

src/doc/rustdoc/src/the-doc-attribute.md

@@ -202,7 +202,7 @@ mod bar {
 Now we'll have a `Re-exports` line, and `Bar` will not link to anywhere.
 
 One special case: In Rust 2018 and later, if you `pub use` one of your dependencies, `rustdoc` will
-not eagerly inline it as a module unless you add `#[doc(inline)}`.
+not eagerly inline it as a module unless you add `#[doc(inline)]`.
 
 ## `#[doc(hidden)]`
 

src/librustc_mir/dataflow/move_paths/builder.rs

@@ -95,15 +95,80 @@ impl<'b, 'a, 'gcx, 'tcx> Gatherer<'b, 'a, 'gcx, 'tcx> {
                      -> Result<MovePathIndex, MoveError<'tcx>>
     {
         debug!("lookup({:?})", place);
-        match *place {
+        place.iterate(|place_base, place_projection| {
-            Place::Base(PlaceBase::Local(local)) => Ok(self.builder.data.rev_lookup.locals[local]),
+            let mut base = match place_base {
-            Place::Base(PlaceBase::Static(..)) => {
+                PlaceBase::Local(local) => self.builder.data.rev_lookup.locals[*local],
-                Err(MoveError::cannot_move_out_of(self.loc, Static))
+                PlaceBase::Static(..) => {
+                    return Err(MoveError::cannot_move_out_of(self.loc, Static));
+                }
+            };
+
+            for proj in place_projection {
+                let mir = self.builder.mir;
+                let tcx = self.builder.tcx;
+                let place_ty = proj.base.ty(mir, tcx).ty;
+                match place_ty.sty {
+                    ty::Ref(..) | ty::RawPtr(..) =>
+                        return Err(MoveError::cannot_move_out_of(
+                            self.loc,
+                            BorrowedContent {
+                                target_place: Place::Projection(Box::new(proj.clone())),
+                            })),
+                    ty::Adt(adt, _) if adt.has_dtor(tcx) && !adt.is_box() =>
+                        return Err(MoveError::cannot_move_out_of(self.loc,
+                                                                 InteriorOfTypeWithDestructor {
+                            container_ty: place_ty
+                        })),
+                    // move out of union - always move the entire union
+                    ty::Adt(adt, _) if adt.is_union() =>
+                        return Err(MoveError::UnionMove { path: base }),
+                    ty::Slice(_) =>
+                        return Err(MoveError::cannot_move_out_of(
+                            self.loc,
+                            InteriorOfSliceOrArray {
+                                ty: place_ty, is_index: match proj.elem {
+                                    ProjectionElem::Index(..) => true,
+                                    _ => false
+                                },
+                            })),
+                    ty::Array(..) => match proj.elem {
+                        ProjectionElem::Index(..) =>
+                            return Err(MoveError::cannot_move_out_of(
+                                self.loc,
+                                InteriorOfSliceOrArray {
+                                    ty: place_ty, is_index: true
+                                })),
+                        _ => {
+                            // FIXME: still badly broken
+                        }
+                    },
+                    _ => {}
+                };
+
+                base = match self
+                    .builder
+                    .data
+                    .rev_lookup
+                    .projections
+                    .entry((base, proj.elem.lift()))
+                {
+                    Entry::Occupied(ent) => *ent.get(),
+                    Entry::Vacant(ent) => {
+                        let path = MoveDataBuilder::new_move_path(
+                            &mut self.builder.data.move_paths,
+                            &mut self.builder.data.path_map,
+                            &mut self.builder.data.init_path_map,
+                            Some(base),
+                            Place::Projection(Box::new(proj.clone())),
+                        );
+                        ent.insert(path);
+                        path
+                    }
+                };
             }
-            Place::Projection(ref proj) => {
+
-                self.move_path_for_projection(place, proj)
+            Ok(base)
-            }
+        })
-        }
     }
 
     fn create_move_path(&mut self, place: &Place<'tcx>) {
@@ -111,66 +176,6 @@ impl<'b, 'a, 'gcx, 'tcx> Gatherer<'b, 'a, 'gcx, 'tcx> {
         // drop), so this not being a valid move path is OK.
         let _ = self.move_path_for(place);
     }
-
-    fn move_path_for_projection(&mut self,
-                                place: &Place<'tcx>,
-                                proj: &Projection<'tcx>)
-                                -> Result<MovePathIndex, MoveError<'tcx>>
-    {
-        let base = self.move_path_for(&proj.base)?;
-        let mir = self.builder.mir;
-        let tcx = self.builder.tcx;
-        let place_ty = proj.base.ty(mir, tcx).ty;
-        match place_ty.sty {
-            ty::Ref(..) | ty::RawPtr(..) =>
-                return Err(MoveError::cannot_move_out_of(
-                    self.loc,
-                    BorrowedContent { target_place: place.clone() })),
-            ty::Adt(adt, _) if adt.has_dtor(tcx) && !adt.is_box() =>
-                return Err(MoveError::cannot_move_out_of(self.loc,
-                                                         InteriorOfTypeWithDestructor {
-                    container_ty: place_ty
-                })),
-            // move out of union - always move the entire union
-            ty::Adt(adt, _) if adt.is_union() =>
-                return Err(MoveError::UnionMove { path: base }),
-            ty::Slice(_) =>
-                return Err(MoveError::cannot_move_out_of(
-                    self.loc,
-                    InteriorOfSliceOrArray {
-                        ty: place_ty, is_index: match proj.elem {
-                            ProjectionElem::Index(..) => true,
-                            _ => false
-                        },
-                    })),
-            ty::Array(..) => match proj.elem {
-                ProjectionElem::Index(..) =>
-                    return Err(MoveError::cannot_move_out_of(
-                        self.loc,
-                        InteriorOfSliceOrArray {
-                            ty: place_ty, is_index: true
-                        })),
-                _ => {
-                    // FIXME: still badly broken
-                }
-            },
-            _ => {}
-        };
-        match self.builder.data.rev_lookup.projections.entry((base, proj.elem.lift())) {
-            Entry::Occupied(ent) => Ok(*ent.get()),
-            Entry::Vacant(ent) => {
-                let path = MoveDataBuilder::new_move_path(
-                    &mut self.builder.data.move_paths,
-                    &mut self.builder.data.path_map,
-                    &mut self.builder.data.init_path_map,
-                    Some(base),
-                    place.clone()
-                );
-                ent.insert(path);
-                Ok(path)
-            }
-        }
-    }
 }
 
 impl<'a, 'gcx, 'tcx> MoveDataBuilder<'a, 'gcx, 'tcx> {

src/librustc_mir/interpret/place.rs

@@ -607,42 +607,42 @@ where
     /// place; for reading, a more efficient alternative is `eval_place_for_read`.
     pub fn eval_place(
         &mut self,
-        mir_place: &mir::Place<'tcx>
+        mir_place: &mir::Place<'tcx>,
     ) -> EvalResult<'tcx, PlaceTy<'tcx, M::PointerTag>> {
-        use rustc::mir::Place::*;
         use rustc::mir::PlaceBase;
-        let place = match mir_place {
+
-            Base(PlaceBase::Local(mir::RETURN_PLACE)) => match self.frame().return_place {
+        mir_place.iterate(|place_base, place_projection| {
-                Some(return_place) =>
+            let mut place = match place_base {
-                    // We use our layout to verify our assumption; caller will validate
+                PlaceBase::Local(mir::RETURN_PLACE) => match self.frame().return_place {
-                    // their layout on return.
+                    Some(return_place) => {
-                    PlaceTy {
+                        // We use our layout to verify our assumption; caller will validate
-                        place: *return_place,
+                        // their layout on return.
-                        layout: self.layout_of(self.monomorphize(self.frame().mir.return_ty())?)?,
+                        PlaceTy {
-                    },
+                            place: *return_place,
-                None => return err!(InvalidNullPointerUsage),
+                            layout: self
-            },
+                                .layout_of(self.monomorphize(self.frame().mir.return_ty())?)?,
-            Base(PlaceBase::Local(local)) => PlaceTy {
+                        }
-                // This works even for dead/uninitialized locals; we check further when writing
+                    }
-                place: Place::Local {
+                    None => return err!(InvalidNullPointerUsage),
-                    frame: self.cur_frame(),
-                    local: *local,
                 },
-                layout: self.layout_of_local(self.frame(), *local, None)?,
+                PlaceBase::Local(local) => PlaceTy {
-            },
+                    // This works even for dead/uninitialized locals; we check further when writing
+                    place: Place::Local {
+                        frame: self.cur_frame(),
+                        local: *local,
+                    },
+                    layout: self.layout_of_local(self.frame(), *local, None)?,
+                },
+                PlaceBase::Static(place_static) => self.eval_static_to_mplace(place_static)?.into(),
+            };
 
-            Projection(proj) => {
+            for proj in place_projection {
-                let place = self.eval_place(&proj.base)?;
+                place = self.place_projection(place, &proj.elem)?
-                self.place_projection(place, &proj.elem)?
             }
 
-            Base(PlaceBase::Static(place_static)) => {
+            self.dump_place(place.place);
-                self.eval_static_to_mplace(place_static)?.into()
+            Ok(place)
-            }
+        })
-        };
-
-        self.dump_place(place.place);
-        Ok(place)
     }
 
     /// Write a scalar to a place

src/libsyntax_pos/symbol.rs

@@ -866,20 +866,13 @@ pub struct Interner {
 }
 
 impl Interner {
-    fn prefill(init: &[&str]) -> Self {
+    fn prefill(init: &[&'static str]) -> Self {
-        let mut this = Interner::default();
+        let symbols = (0 .. init.len() as u32).map(Symbol::new);
-        this.names.reserve(init.len());
+        Interner {
-        this.strings.reserve(init.len());
+            strings: init.to_vec(),
-
+            names: init.iter().copied().zip(symbols).collect(),
-        // We can't allocate empty strings in the arena, so handle this here.
+            ..Default::default()
-        assert!(kw::Invalid.as_u32() == 0 && init[0].is_empty());
-        this.names.insert("", kw::Invalid);
-        this.strings.push("");
-
-        for string in &init[1..] {
-            this.intern(string);
         }
-        this
     }
 
     pub fn intern(&mut self, string: &str) -> Symbol {