OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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

Browse Source 
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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/doc/rustdoc/src/the-doc-attribute.md
View File

@ -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)]`

57
src/librustc_mir/dataflow/move_paths/builder.rs
View File

@ -95,29 +95,15 @@ impl<'b, 'a, 'gcx, 'tcx> Gatherer<'b, 'a, 'gcx, 'tcx> {
-> Result<MovePathIndex, MoveError<'tcx>>
{
debug!("lookup({:?})", place);
match *place {
Place::Base(PlaceBase::Local(local)) => Ok(self.builder.data.rev_lookup.locals[local]),
Place::Base(PlaceBase::Static(..)) => {
Err(MoveError::cannot_move_out_of(self.loc, Static))
}
Place::Projection(ref proj) => {
self.move_path_for_projection(place, proj)
}
}
place.iterate(|place_base, place_projection| {
let mut base = match place_base {
PlaceBase::Local(local) => self.builder.data.rev_lookup.locals[*local],
PlaceBase::Static(..) => {
return Err(MoveError::cannot_move_out_of(self.loc, Static));
}
};
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);
}
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)?;
for proj in place_projection {
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);
}
}

34
src/librustc_mir/interpret/place.rs
View File

@ -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 {
Some(return_place) =>
mir_place.iterate(|place_base, place_projection| {
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)?,
},
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()
}
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

19
src/libsyntax_pos/symbol.rs
View File

@ -866,20 +866,13 @@ pub struct Interner {
}
impl Interner {
fn prefill(init: &[&str]) -> Self {
let mut this = Interner::default();
this.names.reserve(init.len());
this.strings.reserve(init.len());
// We can't allocate empty strings in the arena, so handle this here.
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);
fn prefill(init: &[&'static str]) -> Self {
let symbols = (0 .. init.len() as u32).map(Symbol::new);
Interner {
strings: init.to_vec(),
names: init.iter().copied().zip(symbols).collect(),
..Default::default()
}
this
}
pub fn intern(&mut self, string: &str) -> Symbol {