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,29 +95,15 @@ 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));
-            Place::Projection(ref proj) => {
-                self.move_path_for_projection(place, proj)
-            }
-        }
                 }
+            };
 
-    fn create_move_path(&mut self, place: &Place<'tcx>) {
+            for proj in place_projection {
-        // This is an non-moving access (such as an overwrite or
-        // 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;
@@ -125,7 +111,9 @@ impl<'b, 'a, 'gcx, 'tcx> Gatherer<'b, 'a, 'gcx, 'tcx> {
                     ty::Ref(..) | ty::RawPtr(..) =>
                         return Err(MoveError::cannot_move_out_of(
                             self.loc,
-                    BorrowedContent { target_place: place.clone() })),
+                            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 {
@@ -156,20 +144,37 @@ impl<'b, 'a, 'gcx, 'tcx> Gatherer<'b, 'a, 'gcx, 'tcx> {
                     },
                     _ => {}
                 };
-        match self.builder.data.rev_lookup.projections.entry((base, proj.elem.lift())) {
+
-            Entry::Occupied(ent) => Ok(*ent.get()),
+                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.clone()
+                            Place::Projection(Box::new(proj.clone())),
                         );
                         ent.insert(path);
-                Ok(path)
+                        path
                     }
+                };
             }
+
+            Ok(base)
+        })
+    }
+
+    fn create_move_path(&mut self, place: &Place<'tcx>) {
+        // This is an non-moving access (such as an overwrite or
+        // drop), so this not being a valid move path is OK.
+        let _ = self.move_path_for(place);
     }
 }
 

src/librustc_mir/interpret/place.rs

@@ -607,22 +607,25 @@ 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 {
+                PlaceBase::Local(mir::RETURN_PLACE) => match self.frame().return_place {
+                    Some(return_place) => {
                         // We use our layout to verify our assumption; caller will validate
                         // their layout on return.
                         PlaceTy {
                             place: *return_place,
-                        layout: self.layout_of(self.monomorphize(self.frame().mir.return_ty())?)?,
+                            layout: self
-                    },
+                                .layout_of(self.monomorphize(self.frame().mir.return_ty())?)?,
+                        }
+                    }
                     None => return err!(InvalidNullPointerUsage),
                 },
-            Base(PlaceBase::Local(local)) => PlaceTy {
+                PlaceBase::Local(local) => PlaceTy {
                     // This works even for dead/uninitialized locals; we check further when writing
                     place: Place::Local {
                         frame: self.cur_frame(),
@@ -630,19 +633,16 @@ where
                     },
                     layout: self.layout_of_local(self.frame(), *local, None)?,
                 },
-
+                PlaceBase::Static(place_static) => self.eval_static_to_mplace(place_static)?.into(),
-            Projection(proj) => {
-                let place = self.eval_place(&proj.base)?;
-                self.place_projection(place, &proj.elem)?
-            }
-
-            Base(PlaceBase::Static(place_static)) => {
-                self.eval_static_to_mplace(place_static)?.into()
-            }
             };
 
+            for proj in place_projection {
+                place = self.place_projection(place, &proj.elem)?
+            }
+
             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 {