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
This commit is contained in:
bors 2019-05-26 12:24:25 +00:00
commit dc6db14e1c
4 changed files with 110 additions and 112 deletions

View File

@ -202,7 +202,7 @@ mod bar {
Now we'll have a `Re-exports` line, and `Bar` will not link to anywhere. 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 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)]` ## `#[doc(hidden)]`

View File

@ -95,29 +95,15 @@ impl<'b, 'a, 'gcx, 'tcx> Gatherer<'b, 'a, 'gcx, 'tcx> {
-> Result<MovePathIndex, MoveError<'tcx>> -> Result<MovePathIndex, MoveError<'tcx>>
{ {
debug!("lookup({:?})", place); 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 mir = self.builder.mir;
let tcx = self.builder.tcx; let tcx = self.builder.tcx;
let place_ty = proj.base.ty(mir, tcx).ty; 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(..) => ty::Ref(..) | ty::RawPtr(..) =>
return Err(MoveError::cannot_move_out_of( return Err(MoveError::cannot_move_out_of(
self.loc, 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() => ty::Adt(adt, _) if adt.has_dtor(tcx) && !adt.is_box() =>
return Err(MoveError::cannot_move_out_of(self.loc, return Err(MoveError::cannot_move_out_of(self.loc,
InteriorOfTypeWithDestructor { 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) => { Entry::Vacant(ent) => {
let path = MoveDataBuilder::new_move_path( let path = MoveDataBuilder::new_move_path(
&mut self.builder.data.move_paths, &mut self.builder.data.move_paths,
&mut self.builder.data.path_map, &mut self.builder.data.path_map,
&mut self.builder.data.init_path_map, &mut self.builder.data.init_path_map,
Some(base), Some(base),
place.clone() Place::Projection(Box::new(proj.clone())),
); );
ent.insert(path); 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);
} }
} }

View File

@ -607,22 +607,25 @@ where
/// place; for reading, a more efficient alternative is `eval_place_for_read`. /// place; for reading, a more efficient alternative is `eval_place_for_read`.
pub fn eval_place( pub fn eval_place(
&mut self, &mut self,
mir_place: &mir::Place<'tcx> mir_place: &mir::Place<'tcx>,
) -> EvalResult<'tcx, PlaceTy<'tcx, M::PointerTag>> { ) -> EvalResult<'tcx, PlaceTy<'tcx, M::PointerTag>> {
use rustc::mir::Place::*;
use rustc::mir::PlaceBase; 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 // We use our layout to verify our assumption; caller will validate
// their layout on return. // their layout on return.
PlaceTy { PlaceTy {
place: *return_place, 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), 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 // This works even for dead/uninitialized locals; we check further when writing
place: Place::Local { place: Place::Local {
frame: self.cur_frame(), frame: self.cur_frame(),
@ -630,19 +633,16 @@ where
}, },
layout: self.layout_of_local(self.frame(), *local, None)?, 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); self.dump_place(place.place);
Ok(place) Ok(place)
})
} }
/// Write a scalar to a place /// Write a scalar to a place

View File

@ -866,20 +866,13 @@ pub struct Interner {
} }
impl 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 { pub fn intern(&mut self, string: &str) -> Symbol {