bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Auto merge of #63752 - Centril:rollup-nlxwety, r=Centril

Browse source 
Rollup of 4 pull requests

Successful merges:

 - #62497 (Fix double resolving custom libdir)
 - #63209 (Stabilize `async_await` in Rust 1.39.0)
 - #63746 (Cherry-pick src/test changes with Centril's changes)
 - #63750 (rustc_metadata: replace LazySeq<T> with Lazy<[T]>.)

Failed merges:

r? @ghost
This commit is contained in:
bors 2019-08-20 18:33:16 +00:00
commit bea0372a1a
218 changed files with 802 additions and 1140 deletions
Download patch file Download diff file Expand all files Collapse all files

20
src/bootstrap/builder.rs
View file

@ -618,13 +618,7 @@ impl<'a> Builder<'a> {
}
fn run(self, builder: &Builder<'_>) -> Interned<PathBuf> {
let compiler = self.compiler;
let config = &builder.build.config;
let lib = if compiler.stage >= 1 && config.libdir_relative().is_some() {
builder.build.config.libdir_relative().unwrap()
} else {
Path::new("lib")
};
let lib = builder.sysroot_libdir_relative(self.compiler);
let sysroot = builder
.sysroot(self.compiler)
.join(lib)
@ -678,6 +672,18 @@ impl<'a> Builder<'a> {
}
}
/// Returns the compiler's relative libdir where the standard library and other artifacts are
/// found for a compiler's sysroot.
///
/// For example this returns `lib` on Unix and Windows.
pub fn sysroot_libdir_relative(&self, compiler: Compiler) -> &Path {
match self.config.libdir_relative() {
Some(relative_libdir) if compiler.stage >= 1
=> relative_libdir,
_ => Path::new("lib")
}
}
/// Adds the compiler's directory of dynamic libraries to `cmd`'s dynamic
/// library lookup path.
pub fn add_rustc_lib_path(&self, compiler: Compiler, cmd: &mut Command) {

13
src/bootstrap/dist.rs
View file

@ -469,7 +469,6 @@ impl Step for Rustc {
fn prepare_image(builder: &Builder<'_>, compiler: Compiler, image: &Path) {
let host = compiler.host;
let src = builder.sysroot(compiler);
let libdir = builder.rustc_libdir(compiler);
// Copy rustc/rustdoc binaries
t!(fs::create_dir_all(image.join("bin")));
@ -481,11 +480,14 @@ impl Step for Rustc {
// Copy runtime DLLs needed by the compiler
if libdir_relative.to_str() != Some("bin") {
let libdir = builder.rustc_libdir(compiler);
for entry in builder.read_dir(&libdir) {
let name = entry.file_name();
if let Some(s) = name.to_str() {
if is_dylib(s) {
builder.install(&entry.path(), &image.join(&libdir_relative), 0o644);
// Don't use custom libdir here because ^lib/ will be resolved again
// with installer
builder.install(&entry.path(), &image.join("lib"), 0o644);
}
}
}
@ -493,8 +495,11 @@ impl Step for Rustc {
// Copy over the codegen backends
let backends_src = builder.sysroot_codegen_backends(compiler);
let backends_rel = backends_src.strip_prefix(&src).unwrap();
let backends_dst = image.join(&backends_rel);
let backends_rel = backends_src.strip_prefix(&src).unwrap()
.strip_prefix(builder.sysroot_libdir_relative(compiler)).unwrap();
// Don't use custom libdir here because ^lib/ will be resolved again with installer
let backends_dst = image.join("lib").join(&backends_rel);
t!(fs::create_dir_all(&backends_dst));
builder.cp_r(&backends_src, &backends_dst);

2
src/librustc/error_codes.rs
View file

@ -2088,7 +2088,6 @@ generator can be constructed.
Erroneous code example:
```edition2018,compile-fail,E0698
#![feature(async_await)]
async fn bar<T>() -> () {}
async fn foo() {
@ -2101,7 +2100,6 @@ To fix this you must bind `T` to a concrete type such as `String`
so that a generator can then be constructed:
```edition2018
#![feature(async_await)]
async fn bar<T>() -> () {}
async fn foo() {

8
src/librustc_metadata/cstore.rs
View file

@ -68,9 +68,9 @@ pub struct CrateMetadata {
pub alloc_decoding_state: AllocDecodingState,
// NOTE(eddyb) we pass `'static` to a `'tcx` parameter because this
// lifetime is only used behind `Lazy` / `LazySeq`, and therefore
// acts like an universal (`for<'tcx>`), that is paired up with
// whichever `TyCtxt` is being used to decode those values.
// lifetime is only used behind `Lazy`, and therefore acts like an
// universal (`for<'tcx>`), that is paired up with whichever `TyCtxt`
// is being used to decode those values.
pub root: schema::CrateRoot<'static>,
/// For each definition in this crate, we encode a key. When the
@ -80,7 +80,7 @@ pub struct CrateMetadata {
/// compilation support.
pub def_path_table: Lrc<DefPathTable>,
pub trait_impls: FxHashMap<(u32, DefIndex), schema::LazySeq<DefIndex>>,
pub trait_impls: FxHashMap<(u32, DefIndex), schema::Lazy<[DefIndex]>>,
pub dep_kind: Lock<DepKind>,
pub source: CrateSource,

35
src/librustc_metadata/decoder.rs
View file

@ -134,14 +134,14 @@ impl<'a, 'tcx, T: Decodable> Lazy<T> {
}
}
impl<'a: 'x, 'tcx: 'x, 'x, T: Decodable> LazySeq<T> {
impl<'a: 'x, 'tcx: 'x, 'x, T: Decodable> Lazy<[T]> {
pub fn decode<M: Metadata<'a, 'tcx>>(
self,
meta: M,
) -> impl ExactSizeIterator<Item = T> + Captures<'a> + Captures<'tcx> + 'x {
let mut dcx = meta.decoder(self.position);
dcx.lazy_state = LazyState::NodeStart(self.position);
(0..self.len).map(move |_| T::decode(&mut dcx).unwrap())
(0..self.meta).map(move |_| T::decode(&mut dcx).unwrap())
}
}
@ -154,10 +154,14 @@ impl<'a, 'tcx> DecodeContext<'a, 'tcx> {
self.cdata.expect("missing CrateMetadata in DecodeContext")
}
fn read_lazy_distance(&mut self, min_size: usize) -> Result<usize, <Self as Decoder>::Error> {
fn read_lazy_with_meta<T: ?Sized + LazyMeta>(
&mut self,
meta: T::Meta,
) -> Result<Lazy<T>, <Self as Decoder>::Error> {
let min_size = T::min_size(meta);
let distance = self.read_usize()?;
let position = match self.lazy_state {
LazyState::NoNode => bug!("read_lazy_distance: outside of a metadata node"),
LazyState::NoNode => bug!("read_lazy_with_meta: outside of a metadata node"),
LazyState::NodeStart(start) => {
assert!(distance + min_size <= start);
start - distance - min_size
@ -165,7 +169,7 @@ impl<'a, 'tcx> DecodeContext<'a, 'tcx> {
LazyState::Previous(last_min_end) => last_min_end + distance,
};
self.lazy_state = LazyState::Previous(position + min_size);
Ok(position)
Ok(Lazy::from_position_and_meta(position, meta))
}
}
@ -230,19 +234,18 @@ impl<'a, 'tcx> TyDecoder<'tcx> for DecodeContext<'a, 'tcx> {
impl<'a, 'tcx, T> SpecializedDecoder<Lazy<T>> for DecodeContext<'a, 'tcx> {
fn specialized_decode(&mut self) -> Result<Lazy<T>, Self::Error> {
Ok(Lazy::with_position(self.read_lazy_distance(Lazy::<T>::min_size())?))
self.read_lazy_with_meta(())
}
}
impl<'a, 'tcx, T> SpecializedDecoder<LazySeq<T>> for DecodeContext<'a, 'tcx> {
fn specialized_decode(&mut self) -> Result<LazySeq<T>, Self::Error> {
impl<'a, 'tcx, T> SpecializedDecoder<Lazy<[T]>> for DecodeContext<'a, 'tcx> {
fn specialized_decode(&mut self) -> Result<Lazy<[T]>, Self::Error> {
let len = self.read_usize()?;
let position = if len == 0 {
0
if len == 0 {
Ok(Lazy::empty())
} else {
self.read_lazy_distance(LazySeq::<T>::min_size(len))?
};
Ok(LazySeq::with_position_and_length(position, len))
self.read_lazy_with_meta(len)
}
}
}
@ -378,7 +381,7 @@ impl<'tcx> MetadataBlob {
}
pub fn get_rustc_version(&self) -> String {
Lazy::with_position(METADATA_HEADER.len() + 4).decode(self)
Lazy::<String>::from_position(METADATA_HEADER.len() + 4).decode(self)
}
pub fn get_root(&self) -> CrateRoot<'tcx> {
@ -387,7 +390,7 @@ impl<'tcx> MetadataBlob {
let pos = (((slice[offset + 0] as u32) << 24) | ((slice[offset + 1] as u32) << 16) |
((slice[offset + 2] as u32) << 8) |
((slice[offset + 3] as u32) << 0)) as usize;
Lazy::with_position(pos).decode(self)
Lazy::<CrateRoot<'tcx>>::from_position(pos).decode(self)
}
pub fn list_crate_metadata(&self,
@ -1140,7 +1143,7 @@ impl<'a, 'tcx> CrateMetadata {
EntryKind::Fn(data) |
EntryKind::ForeignFn(data) => data.decode(self).arg_names,
EntryKind::Method(data) => data.decode(self).fn_data.arg_names,
_ => LazySeq::empty(),
_ => Lazy::empty(),
};
arg_names.decode(self).collect()
}

393
src/librustc_metadata/encoder.rs
View file

@ -98,17 +98,17 @@ impl<'tcx> Encoder for EncodeContext<'tcx> {
impl<'tcx, T> SpecializedEncoder<Lazy<T>> for EncodeContext<'tcx> {
fn specialized_encode(&mut self, lazy: &Lazy<T>) -> Result<(), Self::Error> {
self.emit_lazy_distance(lazy.position, Lazy::<T>::min_size())
self.emit_lazy_distance(*lazy)
}
}
impl<'tcx, T> SpecializedEncoder<LazySeq<T>> for EncodeContext<'tcx> {
fn specialized_encode(&mut self, seq: &LazySeq<T>) -> Result<(), Self::Error> {
self.emit_usize(seq.len)?;
if seq.len == 0 {
impl<'tcx, T> SpecializedEncoder<Lazy<[T]>> for EncodeContext<'tcx> {
fn specialized_encode(&mut self, lazy: &Lazy<[T]>) -> Result<(), Self::Error> {
self.emit_usize(lazy.meta)?;
if lazy.meta == 0 {
return Ok(());
}
self.emit_lazy_distance(seq.position, LazySeq::<T>::min_size(seq.len))
self.emit_lazy_distance(*lazy)
}
}
@ -239,21 +239,38 @@ impl<'tcx> TyEncoder for EncodeContext<'tcx> {
}
}
impl<'tcx> EncodeContext<'tcx> {
fn emit_node<F: FnOnce(&mut Self, usize) -> R, R>(&mut self, f: F) -> R {
assert_eq!(self.lazy_state, LazyState::NoNode);
let pos = self.position();
self.lazy_state = LazyState::NodeStart(pos);
let r = f(self, pos);
self.lazy_state = LazyState::NoNode;
r
}
/// Helper trait to allow overloading `EncodeContext::lazy` for iterators.
trait EncodeContentsForLazy<T: ?Sized + LazyMeta> {
fn encode_contents_for_lazy(self, ecx: &mut EncodeContext<'tcx>) -> T::Meta;
}
fn emit_lazy_distance(&mut self,
position: usize,
min_size: usize)
-> Result<(), <Self as Encoder>::Error> {
let min_end = position + min_size;
impl<T: Encodable> EncodeContentsForLazy<T> for &T {
fn encode_contents_for_lazy(self, ecx: &mut EncodeContext<'tcx>) {
self.encode(ecx).unwrap()
}
}
impl<T: Encodable> EncodeContentsForLazy<T> for T {
fn encode_contents_for_lazy(self, ecx: &mut EncodeContext<'tcx>) {
self.encode(ecx).unwrap()
}
}
impl<I, T> EncodeContentsForLazy<[T]> for I
where I: IntoIterator,
I::Item: EncodeContentsForLazy<T>,
{
fn encode_contents_for_lazy(self, ecx: &mut EncodeContext<'tcx>) -> usize {
self.into_iter().map(|value| value.encode_contents_for_lazy(ecx)).count()
}
}
impl<'tcx> EncodeContext<'tcx> {
fn emit_lazy_distance<T: ?Sized + LazyMeta>(
&mut self,
lazy: Lazy<T>,
) -> Result<(), <Self as Encoder>::Error> {
let min_end = lazy.position + T::min_size(lazy.meta);
let distance = match self.lazy_state {
LazyState::NoNode => bug!("emit_lazy_distance: outside of a metadata node"),
LazyState::NodeStart(start) => {
@ -262,48 +279,31 @@ impl<'tcx> EncodeContext<'tcx> {
}
LazyState::Previous(last_min_end) => {
assert!(
last_min_end <= position,
last_min_end <= lazy.position,
"make sure that the calls to `lazy*` \
are in the same order as the metadata fields",
);
position - last_min_end
lazy.position - last_min_end
}
};
self.lazy_state = LazyState::Previous(min_end);
self.emit_usize(distance)
}
pub fn lazy<T: Encodable>(&mut self, value: &T) -> Lazy<T> {
self.emit_node(|ecx, pos| {
value.encode(ecx).unwrap();
fn lazy<T: ?Sized + LazyMeta>(
&mut self,
value: impl EncodeContentsForLazy<T>,
) -> Lazy<T> {
let pos = self.position();
assert!(pos + Lazy::<T>::min_size() <= ecx.position());
Lazy::with_position(pos)
})
}
assert_eq!(self.lazy_state, LazyState::NoNode);
self.lazy_state = LazyState::NodeStart(pos);
let meta = value.encode_contents_for_lazy(self);
self.lazy_state = LazyState::NoNode;
pub fn lazy_seq<I, T>(&mut self, iter: I) -> LazySeq<T>
where I: IntoIterator<Item = T>,
T: Encodable
{
self.emit_node(|ecx, pos| {
let len = iter.into_iter().map(|value| value.encode(ecx).unwrap()).count();
assert!(pos + <T>::min_size(meta) <= self.position());
assert!(pos + LazySeq::<T>::min_size(len) <= ecx.position());
LazySeq::with_position_and_length(pos, len)
})
}
pub fn lazy_seq_ref<'b, I, T>(&mut self, iter: I) -> LazySeq<T>
where I: IntoIterator<Item = &'b T>,
T: 'b + Encodable
{
self.emit_node(|ecx, pos| {
let len = iter.into_iter().map(|value| value.encode(ecx).unwrap()).count();
assert!(pos + LazySeq::<T>::min_size(len) <= ecx.position());
LazySeq::with_position_and_length(pos, len)
})
Lazy::from_position_and_meta(pos, meta)
}
/// Emit the data for a `DefId` to the metadata. The function to
@ -320,7 +320,7 @@ impl<'tcx> EncodeContext<'tcx> {
assert!(id.is_local());
let entry = op(self, data);
let entry = self.lazy(&entry);
let entry = self.lazy(entry);
self.entries_index.record(id, entry);
}
@ -341,7 +341,7 @@ impl<'tcx> EncodeContext<'tcx> {
self.lazy(definitions.def_path_table())
}
fn encode_source_map(&mut self) -> LazySeq<syntax_pos::SourceFile> {
fn encode_source_map(&mut self) -> Lazy<[syntax_pos::SourceFile]> {
let source_map = self.tcx.sess.source_map();
let all_source_files = source_map.files();
@ -380,7 +380,7 @@ impl<'tcx> EncodeContext<'tcx> {
})
.collect::<Vec<_>>();
self.lazy_seq_ref(adapted.iter().map(|rc| &**rc))
self.lazy(adapted.iter().map(|rc| &**rc))
}
fn encode_crate_root(&mut self) -> Lazy<CrateRoot<'tcx>> {
@ -463,7 +463,7 @@ impl<'tcx> EncodeContext<'tcx> {
}
n = new_n;
}
self.lazy_seq(interpret_alloc_index)
self.lazy(interpret_alloc_index)
};
@ -482,8 +482,7 @@ impl<'tcx> EncodeContext<'tcx> {
let has_global_allocator = *tcx.sess.has_global_allocator.get();
let has_panic_handler = *tcx.sess.has_panic_handler.try_get().unwrap_or(&false);
let root = self.lazy(&CrateRoot {
let root = self.lazy(CrateRoot {
name: tcx.crate_name(LOCAL_CRATE),
extra_filename: tcx.sess.opts.cg.extra_filename.clone(),
triple: tcx.sess.opts.target_triple.clone(),
@ -562,17 +561,17 @@ impl<'tcx> EncodeContext<'tcx> {
}
impl EncodeContext<'tcx> {
fn encode_variances_of(&mut self, def_id: DefId) -> LazySeq<ty::Variance> {
fn encode_variances_of(&mut self, def_id: DefId) -> Lazy<[ty::Variance]> {
debug!("EncodeContext::encode_variances_of({:?})", def_id);
let tcx = self.tcx;
self.lazy_seq_ref(&tcx.variances_of(def_id)[..])
self.lazy(&tcx.variances_of(def_id)[..])
}
fn encode_item_type(&mut self, def_id: DefId) -> Lazy<Ty<'tcx>> {
let tcx = self.tcx;
let ty = tcx.type_of(def_id);
debug!("EncodeContext::encode_item_type({:?}) => {:?}", def_id, ty);
self.lazy(&ty)
self.lazy(ty)
}
fn encode_enum_variant_info(
@ -601,11 +600,11 @@ impl EncodeContext<'tcx> {
let enum_vis = &tcx.hir().expect_item(enum_id).vis;
Entry {
kind: EntryKind::Variant(self.lazy(&data)),
visibility: self.lazy(&ty::Visibility::from_hir(enum_vis, enum_id, tcx)),
span: self.lazy(&tcx.def_span(def_id)),
kind: EntryKind::Variant(self.lazy(data)),
visibility: self.lazy(ty::Visibility::from_hir(enum_vis, enum_id, tcx)),
span: self.lazy(tcx.def_span(def_id)),
attributes: self.encode_attributes(&tcx.get_attrs(def_id)),
children: self.lazy_seq(variant.fields.iter().map(|f| {
children: self.lazy(variant.fields.iter().map(|f| {
assert!(f.did.is_local());
f.did.index
})),
@ -613,11 +612,11 @@ impl EncodeContext<'tcx> {
deprecation: self.encode_deprecation(def_id),
ty: Some(self.encode_item_type(def_id)),
inherent_impls: LazySeq::empty(),
inherent_impls: Lazy::empty(),
variances: if variant.ctor_kind == CtorKind::Fn {
self.encode_variances_of(def_id)
} else {
LazySeq::empty()
Lazy::empty()
},
generics: Some(self.encode_generics(def_id)),
predicates: Some(self.encode_predicates(def_id)),
@ -642,7 +641,7 @@ impl EncodeContext<'tcx> {
discr: variant.discr,
ctor: Some(def_id.index),
ctor_sig: if variant.ctor_kind == CtorKind::Fn {
Some(self.lazy(&tcx.fn_sig(def_id)))
Some(self.lazy(tcx.fn_sig(def_id)))
} else {
None
}
@ -658,20 +657,20 @@ impl EncodeContext<'tcx> {
}
Entry {
kind: EntryKind::Variant(self.lazy(&data)),
visibility: self.lazy(&ctor_vis),
span: self.lazy(&tcx.def_span(def_id)),
attributes: LazySeq::empty(),
children: LazySeq::empty(),
kind: EntryKind::Variant(self.lazy(data)),
visibility: self.lazy(ctor_vis),
span: self.lazy(tcx.def_span(def_id)),
attributes: Lazy::empty(),
children: Lazy::empty(),
stability: self.encode_stability(def_id),
deprecation: self.encode_deprecation(def_id),
ty: Some(self.encode_item_type(def_id)),
inherent_impls: LazySeq::empty(),
inherent_impls: Lazy::empty(),
variances: if variant.ctor_kind == CtorKind::Fn {
self.encode_variances_of(def_id)
} else {
LazySeq::empty()
Lazy::empty()
},
generics: Some(self.encode_generics(def_id)),
predicates: Some(self.encode_predicates(def_id)),
@ -691,25 +690,25 @@ impl EncodeContext<'tcx> {
let data = ModData {
reexports: match tcx.module_exports(def_id) {
Some(exports) => self.lazy_seq_ref(exports),
_ => LazySeq::empty(),
Some(exports) => self.lazy(exports),
_ => Lazy::empty(),
},
};
Entry {
kind: EntryKind::Mod(self.lazy(&data)),
visibility: self.lazy(&ty::Visibility::from_hir(vis, id, tcx)),
span: self.lazy(&tcx.def_span(def_id)),
kind: EntryKind::Mod(self.lazy(data)),
visibility: self.lazy(ty::Visibility::from_hir(vis, id, tcx)),
span: self.lazy(tcx.def_span(def_id)),
attributes: self.encode_attributes(attrs),
children: self.lazy_seq(md.item_ids.iter().map(|item_id| {
children: self.lazy(md.item_ids.iter().map(|item_id| {
tcx.hir().local_def_id(item_id.id).index
})),
stability: self.encode_stability(def_id),
deprecation: self.encode_deprecation(def_id),
ty: None,
inherent_impls: LazySeq::empty(),
variances: LazySeq::empty(),
inherent_impls: Lazy::empty(),
variances: Lazy::empty(),
generics: None,
predicates: None,
predicates_defined_on: None,
@ -734,16 +733,16 @@ impl EncodeContext<'tcx> {
Entry {
kind: EntryKind::Field,
visibility: self.lazy(&field.vis),
span: self.lazy(&tcx.def_span(def_id)),
visibility: self.lazy(field.vis),
span: self.lazy(tcx.def_span(def_id)),
attributes: self.encode_attributes(&variant_data.fields()[field_index].attrs),
children: LazySeq::empty(),
children: Lazy::empty(),
stability: self.encode_stability(def_id),
deprecation: self.encode_deprecation(def_id),
ty: Some(self.encode_item_type(def_id)),
inherent_impls: LazySeq::empty(),
variances: LazySeq::empty(),
inherent_impls: Lazy::empty(),
variances: Lazy::empty(),
generics: Some(self.encode_generics(def_id)),
predicates: Some(self.encode_predicates(def_id)),
predicates_defined_on: None,
@ -763,7 +762,7 @@ impl EncodeContext<'tcx> {
discr: variant.discr,
ctor: Some(def_id.index),
ctor_sig: if variant.ctor_kind == CtorKind::Fn {
Some(self.lazy(&tcx.fn_sig(def_id)))
Some(self.lazy(tcx.fn_sig(def_id)))
} else {
None
}
@ -789,20 +788,20 @@ impl EncodeContext<'tcx> {
let repr_options = get_repr_options(tcx, adt_def_id);
Entry {
kind: EntryKind::Struct(self.lazy(&data), repr_options),
visibility: self.lazy(&ctor_vis),
span: self.lazy(&tcx.def_span(def_id)),
attributes: LazySeq::empty(),
children: LazySeq::empty(),
kind: EntryKind::Struct(self.lazy(data), repr_options),
visibility: self.lazy(ctor_vis),
span: self.lazy(tcx.def_span(def_id)),
attributes: Lazy::empty(),
children: Lazy::empty(),
stability: self.encode_stability(def_id),
deprecation: self.encode_deprecation(def_id),
ty: Some(self.encode_item_type(def_id)),
inherent_impls: LazySeq::empty(),
inherent_impls: Lazy::empty(),
variances: if variant.ctor_kind == CtorKind::Fn {
self.encode_variances_of(def_id)
} else {
LazySeq::empty()
Lazy::empty()
},
generics: Some(self.encode_generics(def_id)),
predicates: Some(self.encode_predicates(def_id)),
@ -821,13 +820,13 @@ impl EncodeContext<'tcx> {
fn encode_predicates(&mut self, def_id: DefId) -> Lazy<ty::GenericPredicates<'tcx>> {
debug!("EncodeContext::encode_predicates({:?})", def_id);
let tcx = self.tcx;
self.lazy(&tcx.predicates_of(def_id))
self.lazy(&*tcx.predicates_of(def_id))
}
fn encode_predicates_defined_on(&mut self, def_id: DefId) -> Lazy<ty::GenericPredicates<'tcx>> {
debug!("EncodeContext::encode_predicates_defined_on({:?})", def_id);
let tcx = self.tcx;
self.lazy(&tcx.predicates_defined_on(def_id))
self.lazy(&*tcx.predicates_defined_on(def_id))
}
fn encode_info_for_trait_item(&mut self, def_id: DefId) -> Entry<'tcx> {
@ -858,7 +857,7 @@ impl EncodeContext<'tcx> {
let rendered =
hir::print::to_string(self.tcx.hir(), |s| s.print_trait_item(ast_item));
let rendered_const = self.lazy(&RenderedConst(rendered));
let rendered_const = self.lazy(RenderedConst(rendered));
EntryKind::AssocConst(container, const_qualif, rendered_const)
}
@ -875,12 +874,12 @@ impl EncodeContext<'tcx> {
FnData {
constness: hir::Constness::NotConst,
arg_names,
sig: self.lazy(&tcx.fn_sig(def_id)),
sig: self.lazy(tcx.fn_sig(def_id)),
}
} else {
bug!()
};
EntryKind::Method(self.lazy(&MethodData {
EntryKind::Method(self.lazy(MethodData {
fn_data,
container,
has_self: trait_item.method_has_self_argument,
@ -892,10 +891,10 @@ impl EncodeContext<'tcx> {
Entry {
kind,
visibility: self.lazy(&trait_item.vis),
span: self.lazy(&ast_item.span),
visibility: self.lazy(trait_item.vis),
span: self.lazy(ast_item.span),
attributes: self.encode_attributes(&ast_item.attrs),
children: LazySeq::empty(),
children: Lazy::empty(),
stability: self.encode_stability(def_id),
deprecation: self.encode_deprecation(def_id),
@ -913,11 +912,11 @@ impl EncodeContext<'tcx> {
}
ty::AssocKind::OpaqueTy => unreachable!(),
},
inherent_impls: LazySeq::empty(),
inherent_impls: Lazy::empty(),
variances: if trait_item.kind == ty::AssocKind::Method {
self.encode_variances_of(def_id)
} else {
LazySeq::empty()
Lazy::empty()
},
generics: Some(self.encode_generics(def_id)),
predicates: Some(self.encode_predicates(def_id)),
@ -971,12 +970,12 @@ impl EncodeContext<'tcx> {
FnData {
constness: sig.header.constness,
arg_names: self.encode_fn_arg_names_for_body(body),
sig: self.lazy(&tcx.fn_sig(def_id)),
sig: self.lazy(tcx.fn_sig(def_id)),
}
} else {
bug!()
};
EntryKind::Method(self.lazy(&MethodData {
EntryKind::Method(self.lazy(MethodData {
fn_data,
container,
has_self: impl_item.method_has_self_argument,
@ -1004,19 +1003,19 @@ impl EncodeContext<'tcx> {
Entry {
kind,
visibility: self.lazy(&impl_item.vis),
span: self.lazy(&ast_item.span),
visibility: self.lazy(impl_item.vis),
span: self.lazy(ast_item.span),
attributes: self.encode_attributes(&ast_item.attrs),
children: LazySeq::empty(),
children: Lazy::empty(),
stability: self.encode_stability(def_id),
deprecation: self.encode_deprecation(def_id),
ty: Some(self.encode_item_type(def_id)),
inherent_impls: LazySeq::empty(),
inherent_impls: Lazy::empty(),
variances: if impl_item.kind == ty::AssocKind::Method {
self.encode_variances_of(def_id)
} else {
LazySeq::empty()
Lazy::empty()
},
generics: Some(self.encode_generics(def_id)),
predicates: Some(self.encode_predicates(def_id)),
@ -1027,10 +1026,10 @@ impl EncodeContext<'tcx> {
}
fn encode_fn_arg_names_for_body(&mut self, body_id: hir::BodyId)
-> LazySeq<ast::Name> {
-> Lazy<[ast::Name]> {
self.tcx.dep_graph.with_ignore(|| {
let body = self.tcx.hir().body(body_id);
self.lazy_seq(body.arguments.iter().map(|arg| {
self.lazy(body.arguments.iter().map(|arg| {
match arg.pat.node {
PatKind::Binding(_, _, ident, _) => ident.name,
_ => kw::Invalid,
@ -1039,28 +1038,28 @@ impl EncodeContext<'tcx> {
})
}
fn encode_fn_arg_names(&mut self, param_names: &[ast::Ident]) -> LazySeq<ast::Name> {
self.lazy_seq(param_names.iter().map(|ident| ident.name))
fn encode_fn_arg_names(&mut self, param_names: &[ast::Ident]) -> Lazy<[ast::Name]> {
self.lazy(param_names.iter().map(|ident| ident.name))
}
fn encode_optimized_mir(&mut self, def_id: DefId) -> Option<Lazy<mir::Body<'tcx>>> {
debug!("EntryBuilder::encode_mir({:?})", def_id);
if self.tcx.mir_keys(LOCAL_CRATE).contains(&def_id) {
let mir = self.tcx.optimized_mir(def_id);
Some(self.lazy(&mir))
Some(self.lazy(mir))
} else {
None
}
}
// Encodes the inherent implementations of a structure, enumeration, or trait.
fn encode_inherent_implementations(&mut self, def_id: DefId) -> LazySeq<DefIndex> {
fn encode_inherent_implementations(&mut self, def_id: DefId) -> Lazy<[DefIndex]> {
debug!("EncodeContext::encode_inherent_implementations({:?})", def_id);
let implementations = self.tcx.inherent_impls(def_id);
if implementations.is_empty() {
LazySeq::empty()
Lazy::empty()
} else {
self.lazy_seq(implementations.iter().map(|&def_id| {
self.lazy(implementations.iter().map(|&def_id| {
assert!(def_id.is_local());
def_id.index
}))
@ -1074,7 +1073,7 @@ impl EncodeContext<'tcx> {
fn encode_deprecation(&mut self, def_id: DefId) -> Option<Lazy<attr::Deprecation>> {
debug!("EncodeContext::encode_deprecation({:?})", def_id);
self.tcx.lookup_deprecation(def_id).map(|depr| self.lazy(&depr))
self.tcx.lookup_deprecation(def_id).map(|depr| self.lazy(depr))
}
fn encode_rendered_const_for_body(&mut self, body_id: hir::BodyId) -> Lazy<RenderedConst> {
@ -1103,10 +1102,10 @@ impl EncodeContext<'tcx> {
let data = FnData {
constness: header.constness,
arg_names: self.encode_fn_arg_names_for_body(body),
sig: self.lazy(&tcx.fn_sig(def_id)),
sig: self.lazy(tcx.fn_sig(def_id)),
};
EntryKind::Fn(self.lazy(&data))
EntryKind::Fn(self.lazy(data))
}
hir::ItemKind::Mod(ref m) => {
return self.encode_info_for_mod((item.hir_id, m, &item.attrs, &item.vis));
@ -1127,7 +1126,7 @@ impl EncodeContext<'tcx> {
let repr_options = get_repr_options(tcx, def_id);
EntryKind::Struct(self.lazy(&VariantData {
EntryKind::Struct(self.lazy(VariantData {
ctor_kind: variant.ctor_kind,
discr: variant.discr,
ctor,
@ -1138,7 +1137,7 @@ impl EncodeContext<'tcx> {
let variant = tcx.adt_def(def_id).non_enum_variant();
let repr_options = get_repr_options(tcx, def_id);
EntryKind::Union(self.lazy(&VariantData {
EntryKind::Union(self.lazy(VariantData {
ctor_kind: variant.ctor_kind,
discr: variant.discr,
ctor: None,
@ -1175,10 +1174,10 @@ impl EncodeContext<'tcx> {
defaultness,
parent_impl: parent,
coerce_unsized_info,
trait_ref: trait_ref.map(|trait_ref| self.lazy(&trait_ref)),
trait_ref: trait_ref.map(|trait_ref| self.lazy(trait_ref)),
};
EntryKind::Impl(self.lazy(&data))
EntryKind::Impl(self.lazy(data))
}
hir::ItemKind::Trait(..) => {
let trait_def = tcx.trait_def(def_id);
@ -1187,17 +1186,17 @@ impl EncodeContext<'tcx> {
paren_sugar: trait_def.paren_sugar,
has_auto_impl: tcx.trait_is_auto(def_id),
is_marker: trait_def.is_marker,
super_predicates: self.lazy(&tcx.super_predicates_of(def_id)),
super_predicates: self.lazy(&*tcx.super_predicates_of(def_id)),
};
EntryKind::Trait(self.lazy(&data))
EntryKind::Trait(self.lazy(data))
}
hir::ItemKind::TraitAlias(..) => {
let data = TraitAliasData {
super_predicates: self.lazy(&tcx.super_predicates_of(def_id)),
super_predicates: self.lazy(&*tcx.super_predicates_of(def_id)),
};
EntryKind::TraitAlias(self.lazy(&data))
EntryKind::TraitAlias(self.lazy(data))
}
hir::ItemKind::ExternCrate(_) |
hir::ItemKind::Use(..) => bug!("cannot encode info for item {:?}", item),
@ -1205,19 +1204,19 @@ impl EncodeContext<'tcx> {
Entry {
kind,
visibility: self.lazy(&ty::Visibility::from_hir(&item.vis, item.hir_id, tcx)),
span: self.lazy(&item.span),
visibility: self.lazy(ty::Visibility::from_hir(&item.vis, item.hir_id, tcx)),
span: self.lazy(item.span),
attributes: self.encode_attributes(&item.attrs),
children: match item.node {
hir::ItemKind::ForeignMod(ref fm) => {
self.lazy_seq(fm.items
self.lazy(fm.items
.iter()
.map(|foreign_item| tcx.hir().local_def_id(
foreign_item.hir_id).index))
}
hir::ItemKind::Enum(..) => {
let def = self.tcx.adt_def(def_id);
self.lazy_seq(def.variants.iter().map(|v| {
self.lazy(def.variants.iter().map(|v| {
assert!(v.def_id.is_local());
v.def_id.index
}))
@ -1225,19 +1224,19 @@ impl EncodeContext<'tcx> {
hir::ItemKind::Struct(..) |
hir::ItemKind::Union(..) => {
let def = self.tcx.adt_def(def_id);
self.lazy_seq(def.non_enum_variant().fields.iter().map(|f| {
self.lazy(def.non_enum_variant().fields.iter().map(|f| {
assert!(f.did.is_local());
f.did.index
}))
}
hir::ItemKind::Impl(..) |
hir::ItemKind::Trait(..) => {
self.lazy_seq(tcx.associated_item_def_ids(def_id).iter().map(|&def_id| {
self.lazy(tcx.associated_item_def_ids(def_id).iter().map(|&def_id| {
assert!(def_id.is_local());
def_id.index
}))
}
_ => LazySeq::empty(),
_ => Lazy::empty(),
},
stability: self.encode_stability(def_id),
deprecation: self.encode_deprecation(def_id),
@ -1260,7 +1259,7 @@ impl EncodeContext<'tcx> {
hir::ItemKind::Struct(..) |
hir::ItemKind::Union(..) |
hir::ItemKind::Fn(..) => self.encode_variances_of(def_id),
_ => LazySeq::empty(),
_ => Lazy::empty(),
},
generics: match item.node {
hir::ItemKind::Static(..) |
@ -1333,20 +1332,20 @@ impl EncodeContext<'tcx> {
use syntax::print::pprust;
let def_id = self.tcx.hir().local_def_id(macro_def.hir_id);
Entry {
kind: EntryKind::MacroDef(self.lazy(&MacroDef {
kind: EntryKind::MacroDef(self.lazy(MacroDef {
body: pprust::tokens_to_string(macro_def.body.clone()),
legacy: macro_def.legacy,
})),
visibility: self.lazy(&ty::Visibility::Public),
span: self.lazy(&macro_def.span),
visibility: self.lazy(ty::Visibility::Public),
span: self.lazy(macro_def.span),
attributes: self.encode_attributes(&macro_def.attrs),
stability: self.encode_stability(def_id),
deprecation: self.encode_deprecation(def_id),
children: LazySeq::empty(),
children: Lazy::empty(),
ty: None,
inherent_impls: LazySeq::empty(),
variances: LazySeq::empty(),
inherent_impls: Lazy::empty(),
variances: Lazy::empty(),
generics: None,
predicates: None,
predicates_defined_on: None,
@ -1363,15 +1362,15 @@ impl EncodeContext<'tcx> {
let tcx = self.tcx;
Entry {
kind: entry_kind,
visibility: self.lazy(&ty::Visibility::Public),
span: self.lazy(&tcx.def_span(def_id)),
attributes: LazySeq::empty(),
children: LazySeq::empty(),
visibility: self.lazy(ty::Visibility::Public),
span: self.lazy(tcx.def_span(def_id)),
attributes: Lazy::empty(),
children: Lazy::empty(),
stability: None,
deprecation: None,
ty: if encode_type { Some(self.encode_item_type(def_id)) } else { None },
inherent_impls: LazySeq::empty(),
variances: LazySeq::empty(),
inherent_impls: Lazy::empty(),
variances: Lazy::empty(),
generics: None,
predicates: None,
predicates_defined_on: None,
@ -1408,13 +1407,13 @@ impl EncodeContext<'tcx> {
let data = GeneratorData {
layout: layout.clone(),
};
EntryKind::Generator(self.lazy(&data))
EntryKind::Generator(self.lazy(data))
}
ty::Closure(def_id, substs) => {
let sig = substs.closure_sig(def_id, self.tcx);
let data = ClosureData { sig: self.lazy(&sig) };
EntryKind::Closure(self.lazy(&data))
let data = ClosureData { sig: self.lazy(sig) };
EntryKind::Closure(self.lazy(data))
}
_ => bug!("closure that is neither generator nor closure")
@ -1422,16 +1421,16 @@ impl EncodeContext<'tcx> {
Entry {
kind,
visibility: self.lazy(&ty::Visibility::Public),
span: self.lazy(&tcx.def_span(def_id)),
visibility: self.lazy(ty::Visibility::Public),
span: self.lazy(tcx.def_span(def_id)),
attributes: self.encode_attributes(&tcx.get_attrs(def_id)),
children: LazySeq::empty(),
children: Lazy::empty(),
stability: None,
deprecation: None,
ty: Some(self.encode_item_type(def_id)),
inherent_impls: LazySeq::empty(),
variances: LazySeq::empty(),
inherent_impls: Lazy::empty(),
variances: Lazy::empty(),
generics: Some(self.encode_generics(def_id)),
predicates: None,
predicates_defined_on: None,
@ -1450,16 +1449,16 @@ impl EncodeContext<'tcx> {
Entry {
kind: EntryKind::Const(self.const_qualif(mir, body_id), const_data),
visibility: self.lazy(&ty::Visibility::Public),
span: self.lazy(&tcx.def_span(def_id)),
attributes: LazySeq::empty(),
children: LazySeq::empty(),
visibility: self.lazy(ty::Visibility::Public),
span: self.lazy(tcx.def_span(def_id)),
attributes: Lazy::empty(),
children: Lazy::empty(),
stability: None,
deprecation: None,
ty: Some(self.encode_item_type(def_id)),
inherent_impls: LazySeq::empty(),
variances: LazySeq::empty(),
inherent_impls: Lazy::empty(),
variances: Lazy::empty(),
generics: Some(self.encode_generics(def_id)),
predicates: Some(self.encode_predicates(def_id)),
predicates_defined_on: None,
@ -1468,37 +1467,37 @@ impl EncodeContext<'tcx> {
}
}
fn encode_attributes(&mut self, attrs: &[ast::Attribute]) -> LazySeq<ast::Attribute> {
self.lazy_seq_ref(attrs)
fn encode_attributes(&mut self, attrs: &[ast::Attribute]) -> Lazy<[ast::Attribute]> {
self.lazy(attrs)
}
fn encode_native_libraries(&mut self) -> LazySeq<NativeLibrary> {
fn encode_native_libraries(&mut self) -> Lazy<[NativeLibrary]> {
let used_libraries = self.tcx.native_libraries(LOCAL_CRATE);
self.lazy_seq(used_libraries.iter().cloned())
self.lazy(used_libraries.iter().cloned())
}
fn encode_foreign_modules(&mut self) -> LazySeq<ForeignModule> {
fn encode_foreign_modules(&mut self) -> Lazy<[ForeignModule]> {
let foreign_modules = self.tcx.foreign_modules(LOCAL_CRATE);
self.lazy_seq(foreign_modules.iter().cloned())
self.lazy(foreign_modules.iter().cloned())
}
fn encode_proc_macros(&mut self) -> Option<LazySeq<DefIndex>> {
fn encode_proc_macros(&mut self) -> Option<Lazy<[DefIndex]>> {
let is_proc_macro = self.tcx.sess.crate_types.borrow().contains(&CrateType::ProcMacro);
if is_proc_macro {
let proc_macros: Vec<_> = self.tcx.hir().krate().items.values().filter_map(|item| {
let tcx = self.tcx;
Some(self.lazy(tcx.hir().krate().items.values().filter_map(|item| {
if item.attrs.iter().any(|attr| is_proc_macro_attr(attr)) {
Some(item.hir_id.owner)
} else {
None
}
}).collect();
Some(self.lazy_seq(proc_macros))
})))
} else {
None
}
}
fn encode_crate_deps(&mut self) -> LazySeq<CrateDep> {
fn encode_crate_deps(&mut self) -> Lazy<[CrateDep]> {
let crates = self.tcx.crates();
let mut deps = crates
@ -1529,20 +1528,20 @@ impl EncodeContext<'tcx> {
// the assumption that they are numbered 1 to n.
// FIXME (#2166): This is not nearly enough to support correct versioning
// but is enough to get transitive crate dependencies working.
self.lazy_seq_ref(deps.iter().map(|&(_, ref dep)| dep))
self.lazy(deps.iter().map(|&(_, ref dep)| dep))
}
fn encode_lib_features(&mut self) -> LazySeq<(ast::Name, Option<ast::Name>)> {
fn encode_lib_features(&mut self) -> Lazy<[(ast::Name, Option<ast::Name>)]> {
let tcx = self.tcx;
let lib_features = tcx.lib_features();
self.lazy_seq(lib_features.to_vec())
self.lazy(lib_features.to_vec())
}
fn encode_lang_items(&mut self) -> LazySeq<(DefIndex, usize)> {
fn encode_lang_items(&mut self) -> Lazy<[(DefIndex, usize)]> {
let tcx = self.tcx;
let lang_items = tcx.lang_items();
let lang_items = lang_items.items().iter();
self.lazy_seq(lang_items.enumerate().filter_map(|(i, &opt_def_id)| {
self.lazy(lang_items.enumerate().filter_map(|(i, &opt_def_id)| {
if let Some(def_id) = opt_def_id {
if def_id.is_local() {
return Some((def_id.index, i));
@ -1552,13 +1551,13 @@ impl EncodeContext<'tcx> {
}))
}
fn encode_lang_items_missing(&mut self) -> LazySeq<lang_items::LangItem> {
fn encode_lang_items_missing(&mut self) -> Lazy<[lang_items::LangItem]> {
let tcx = self.tcx;
self.lazy_seq_ref(&tcx.lang_items().missing)
self.lazy(&tcx.lang_items().missing)
}
/// Encodes an index, mapping each trait to its (local) implementations.
fn encode_impls(&mut self) -> LazySeq<TraitImpls> {
fn encode_impls(&mut self) -> Lazy<[TraitImpls]> {
debug!("EncodeContext::encode_impls()");
let tcx = self.tcx;
let mut visitor = ImplVisitor {
@ -1584,12 +1583,12 @@ impl EncodeContext<'tcx> {
TraitImpls {
trait_id: (trait_def_id.krate.as_u32(), trait_def_id.index),
impls: self.lazy_seq_ref(&impls),
impls: self.lazy(&impls),
}
})
.collect();
self.lazy_seq_ref(&all_impls)
self.lazy(&all_impls)
}
// Encodes all symbols exported from this crate into the metadata.
@ -1600,12 +1599,12 @@ impl EncodeContext<'tcx> {
// definition (as that's not defined in this crate).
fn encode_exported_symbols(&mut self,
exported_symbols: &[(ExportedSymbol<'tcx>, SymbolExportLevel)])
-> LazySeq<(ExportedSymbol<'tcx>, SymbolExportLevel)> {
-> Lazy<[(ExportedSymbol<'tcx>, SymbolExportLevel)]> {
// The metadata symbol name is special. It should not show up in
// downstream crates.
let metadata_symbol_name = SymbolName::new(&metadata_symbol_name(self.tcx));
self.lazy_seq(exported_symbols
self.lazy(exported_symbols
.iter()
.filter(|&&(ref exported_symbol, _)| {
match *exported_symbol {
@ -1618,10 +1617,10 @@ impl EncodeContext<'tcx> {
.cloned())
}
fn encode_dylib_dependency_formats(&mut self) -> LazySeq<Option<LinkagePreference>> {
fn encode_dylib_dependency_formats(&mut self) -> Lazy<[Option<LinkagePreference>]> {
match self.tcx.sess.dependency_formats.borrow().get(&config::CrateType::Dylib) {
Some(arr) => {
self.lazy_seq(arr.iter().map(|slot| {
self.lazy(arr.iter().map(|slot| {
match *slot {
Linkage::NotLinked |
Linkage::IncludedFromDylib => None,
@ -1631,7 +1630,7 @@ impl EncodeContext<'tcx> {
}
}))
}
None => LazySeq::empty(),
None => Lazy::empty(),
}
}
@ -1647,9 +1646,9 @@ impl EncodeContext<'tcx> {
let data = FnData {
constness: hir::Constness::NotConst,
arg_names: self.encode_fn_arg_names(names),
sig: self.lazy(&tcx.fn_sig(def_id)),
sig: self.lazy(tcx.fn_sig(def_id)),
};
EntryKind::ForeignFn(self.lazy(&data))
EntryKind::ForeignFn(self.lazy(data))
}
hir::ForeignItemKind::Static(_, hir::MutMutable) => EntryKind::ForeignMutStatic,
hir::ForeignItemKind::Static(_, hir::MutImmutable) => EntryKind::ForeignImmStatic,
@ -1658,18 +1657,18 @@ impl EncodeContext<'tcx> {
Entry {
kind,
visibility: self.lazy(&ty::Visibility::from_hir(&nitem.vis, nitem.hir_id, tcx)),
span: self.lazy(&nitem.span),
visibility: self.lazy(ty::Visibility::from_hir(&nitem.vis, nitem.hir_id, tcx)),
span: self.lazy(nitem.span),
attributes: self.encode_attributes(&nitem.attrs),
children: LazySeq::empty(),
children: Lazy::empty(),
stability: self.encode_stability(def_id),
deprecation: self.encode_deprecation(def_id),
ty: Some(self.encode_item_type(def_id)),
inherent_impls: LazySeq::empty(),
inherent_impls: Lazy::empty(),
variances: match nitem.node {
hir::ForeignItemKind::Fn(..) => self.encode_variances_of(def_id),
_ => LazySeq::empty(),
_ => Lazy::empty(),
},
generics: Some(self.encode_generics(def_id)),
predicates: Some(self.encode_predicates(def_id)),

10
src/librustc_metadata/index.rs
View file

@ -108,18 +108,18 @@ impl Index<'tcx> {
position.write_to_bytes_at(positions, array_index)
}
pub fn write_index(&self, buf: &mut Encoder) -> LazySeq<Self> {
pub fn write_index(&self, buf: &mut Encoder) -> Lazy<[Self]> {
let pos = buf.position();
// First we write the length of the lower range ...
buf.emit_raw_bytes(&(self.positions.len() as u32 / 4).to_le_bytes());
// ... then the values.
buf.emit_raw_bytes(&self.positions);
LazySeq::with_position_and_length(pos as usize, self.positions.len() / 4 + 1)
Lazy::from_position_and_meta(pos as usize, self.positions.len() / 4 + 1)
}
}
impl LazySeq<Index<'tcx>> {
impl Lazy<[Index<'tcx>]> {
/// Given the metadata, extract out the offset of a particular
/// DefIndex (if any).
#[inline(never)]
@ -127,7 +127,7 @@ impl LazySeq<Index<'tcx>> {
let bytes = &bytes[self.position..];
debug!("Index::lookup: index={:?} len={:?}",
def_index,
self.len);
self.meta);
let position = u32::read_from_bytes_at(bytes, 1 + def_index.index());
if position == u32::MAX {
@ -135,7 +135,7 @@ impl LazySeq<Index<'tcx>> {
None
} else {
debug!("Index::lookup: position={:?}", position);
Some(Lazy::with_position(position as usize))
Some(Lazy::from_position(position as usize))
}
}
}

153
src/librustc_metadata/schema.rs
View file

@ -41,6 +41,33 @@ pub const METADATA_VERSION: u8 = 4;
pub const METADATA_HEADER: &[u8; 12] =
&[0, 0, 0, 0, b'r', b'u', b's', b't', 0, 0, 0, METADATA_VERSION];
/// Additional metadata for a `Lazy<T>` where `T` may not be `Sized`,
/// e.g. for `Lazy<[T]>`, this is the length (count of `T` values).
pub trait LazyMeta {
type Meta: Copy + 'static;
/// Returns the minimum encoded size.
// FIXME(eddyb) Give better estimates for certain types.
fn min_size(meta: Self::Meta) -> usize;
}
impl<T> LazyMeta for T {
type Meta = ();
fn min_size(_: ()) -> usize {
assert_ne!(std::mem::size_of::<T>(), 0);
1
}
}
impl<T> LazyMeta for [T] {
type Meta = usize;
fn min_size(len: usize) -> usize {
len * T::min_size(())
}
}
/// A value of type T referred to by its absolute position
/// in the metadata, and which can be decoded lazily.
///
@ -56,40 +83,8 @@ pub const METADATA_HEADER: &[u8; 12] =
/// Distances start at 1, as 0-byte nodes are invalid.
/// Also invalid are nodes being referred in a different
/// order than they were encoded in.
#[must_use]
pub struct Lazy<T> {
pub position: usize,
_marker: PhantomData<T>,
}
impl<T> Lazy<T> {
pub fn with_position(position: usize) -> Lazy<T> {
Lazy {
position,
_marker: PhantomData,
}
}
/// Returns the minimum encoded size of a value of type `T`.
// FIXME(eddyb) Give better estimates for certain types.
pub fn min_size() -> usize {
1
}
}
impl<T> Copy for Lazy<T> {}
impl<T> Clone for Lazy<T> {
fn clone(&self) -> Self {
*self
}
}
impl<T> rustc_serialize::UseSpecializedEncodable for Lazy<T> {}
impl<T> rustc_serialize::UseSpecializedDecodable for Lazy<T> {}
/// A sequence of type T referred to by its absolute position
/// in the metadata and length, and which can be decoded lazily.
/// The sequence is a single node for the purposes of `Lazy`.
///
/// # Sequences (`Lazy<[T]>`)
///
/// Unlike `Lazy<Vec<T>>`, the length is encoded next to the
/// position, not at the position, which means that the length
@ -100,54 +95,62 @@ impl<T> rustc_serialize::UseSpecializedDecodable for Lazy<T> {}
/// the minimal distance the length of the sequence, i.e.
/// it's assumed there's no 0-byte element in the sequence.
#[must_use]
pub struct LazySeq<T> {
pub len: usize,
// FIXME(#59875) the `Meta` parameter only exists to dodge
// invariance wrt `T` (coming from the `meta: T::Meta` field).
pub struct Lazy<T, Meta = <T as LazyMeta>::Meta>
where T: ?Sized + LazyMeta<Meta = Meta>,
Meta: 'static + Copy,
{
pub position: usize,
pub meta: Meta,
_marker: PhantomData<T>,
}
impl<T> LazySeq<T> {
pub fn empty() -> LazySeq<T> {
LazySeq::with_position_and_length(0, 0)
}
pub fn with_position_and_length(position: usize, len: usize) -> LazySeq<T> {
LazySeq {
len,
impl<T: ?Sized + LazyMeta> Lazy<T> {
pub fn from_position_and_meta(position: usize, meta: T::Meta) -> Lazy<T> {
Lazy {
position,
meta,
_marker: PhantomData,
}
}
}
/// Returns the minimum encoded size of `length` values of type `T`.
pub fn min_size(length: usize) -> usize {
length
impl<T> Lazy<T> {
pub fn from_position(position: usize) -> Lazy<T> {
Lazy::from_position_and_meta(position, ())
}
}
impl<T> Copy for LazySeq<T> {}
impl<T> Clone for LazySeq<T> {
impl<T> Lazy<[T]> {
pub fn empty() -> Lazy<[T]> {
Lazy::from_position_and_meta(0, 0)
}
}
impl<T: ?Sized + LazyMeta> Copy for Lazy<T> {}
impl<T: ?Sized + LazyMeta> Clone for Lazy<T> {
fn clone(&self) -> Self {
*self
}
}
impl<T> rustc_serialize::UseSpecializedEncodable for LazySeq<T> {}
impl<T> rustc_serialize::UseSpecializedDecodable for LazySeq<T> {}
impl<T: ?Sized + LazyMeta> rustc_serialize::UseSpecializedEncodable for Lazy<T> {}
impl<T: ?Sized + LazyMeta> rustc_serialize::UseSpecializedDecodable for Lazy<T> {}
/// Encoding / decoding state for `Lazy` and `LazySeq`.
/// Encoding / decoding state for `Lazy`.
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub enum LazyState {
/// Outside of a metadata node.
NoNode,
/// Inside a metadata node, and before any `Lazy` or `LazySeq`.
/// Inside a metadata node, and before any `Lazy`.
/// The position is that of the node itself.
NodeStart(usize),
/// Inside a metadata node, with a previous `Lazy` or `LazySeq`.
/// Inside a metadata node, with a previous `Lazy`.
/// The position is a conservative estimate of where that
/// previous `Lazy` / `LazySeq` would end (see their comments).
/// previous `Lazy` would end (see their comments).
Previous(usize),
}
@ -167,24 +170,24 @@ pub struct CrateRoot<'tcx> {
pub proc_macro_decls_static: Option<DefIndex>,
pub proc_macro_stability: Option<attr::Stability>,
pub crate_deps: LazySeq<CrateDep>,
pub dylib_dependency_formats: LazySeq<Option<LinkagePreference>>,
pub lib_features: LazySeq<(Symbol, Option<Symbol>)>,
pub lang_items: LazySeq<(DefIndex, usize)>,
pub lang_items_missing: LazySeq<lang_items::LangItem>,
pub native_libraries: LazySeq<NativeLibrary>,
pub foreign_modules: LazySeq<ForeignModule>,
pub source_map: LazySeq<syntax_pos::SourceFile>,
pub crate_deps: Lazy<[CrateDep]>,
pub dylib_dependency_formats: Lazy<[Option<LinkagePreference>]>,
pub lib_features: Lazy<[(Symbol, Option<Symbol>)]>,
pub lang_items: Lazy<[(DefIndex, usize)]>,
pub lang_items_missing: Lazy<[lang_items::LangItem]>,
pub native_libraries: Lazy<[NativeLibrary]>,
pub foreign_modules: Lazy<[ForeignModule]>,
pub source_map: Lazy<[syntax_pos::SourceFile]>,
pub def_path_table: Lazy<hir::map::definitions::DefPathTable>,
pub impls: LazySeq<TraitImpls>,
pub exported_symbols: LazySeq<(ExportedSymbol<'tcx>, SymbolExportLevel)>,
pub interpret_alloc_index: LazySeq<u32>,
pub impls: Lazy<[TraitImpls]>,
pub exported_symbols: Lazy<[(ExportedSymbol<'tcx>, SymbolExportLevel)]>,
pub interpret_alloc_index: Lazy<[u32]>,
pub entries_index: LazySeq<index::Index<'tcx>>,
pub entries_index: Lazy<[index::Index<'tcx>]>,
/// The DefIndex's of any proc macros delcared by
/// this crate
pub proc_macro_data: Option<LazySeq<DefIndex>>,
pub proc_macro_data: Option<Lazy<[DefIndex]>>,
pub compiler_builtins: bool,
pub needs_allocator: bool,
@ -207,7 +210,7 @@ pub struct CrateDep {
#[derive(RustcEncodable, RustcDecodable)]
pub struct TraitImpls {
pub trait_id: (u32, DefIndex),
pub impls: LazySeq<DefIndex>,
pub impls: Lazy<[DefIndex]>,
}
#[derive(RustcEncodable, RustcDecodable)]
@ -215,14 +218,14 @@ pub struct Entry<'tcx> {
pub kind: EntryKind<'tcx>,
pub visibility: Lazy<ty::Visibility>,
pub span: Lazy<Span>,
pub attributes: LazySeq<ast::Attribute>,
pub children: LazySeq<DefIndex>,
pub attributes: Lazy<[ast::Attribute]>,
pub children: Lazy<[DefIndex]>,
pub stability: Option<Lazy<attr::Stability>>,
pub deprecation: Option<Lazy<attr::Deprecation>>,
pub ty: Option<Lazy<Ty<'tcx>>>,
pub inherent_impls: LazySeq<DefIndex>,
pub variances: LazySeq<ty::Variance>,
pub inherent_impls: Lazy<[DefIndex]>,
pub variances: Lazy<[ty::Variance]>,
pub generics: Option<Lazy<ty::Generics>>,
pub predicates: Option<Lazy<ty::GenericPredicates<'tcx>>>,
pub predicates_defined_on: Option<Lazy<ty::GenericPredicates<'tcx>>>,
@ -278,7 +281,7 @@ pub struct RenderedConst(pub String);
#[derive(RustcEncodable, RustcDecodable)]
pub struct ModData {
pub reexports: LazySeq<def::Export<hir::HirId>>,
pub reexports: Lazy<[def::Export<hir::HirId>]>,
}
#[derive(RustcEncodable, RustcDecodable)]
@ -290,7 +293,7 @@ pub struct MacroDef {
#[derive(RustcEncodable, RustcDecodable)]
pub struct FnData<'tcx> {
pub constness: hir::Constness,
pub arg_names: LazySeq<ast::Name>,
pub arg_names: Lazy<[ast::Name]>,
pub sig: Lazy<ty::PolyFnSig<'tcx>>,
}

2
src/librustc_typeck/check/mod.rs
View file

@ -4197,8 +4197,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
/// A possible error is to forget to add `.await` when using futures:
///
/// ```
/// #![feature(async_await)]
///
/// async fn make_u32() -> u32 {
/// 22
/// }

7
src/librustc_typeck/error_codes.rs
View file

@ -4751,7 +4751,6 @@ E0733: r##"
Recursion in an `async fn` requires boxing. For example, this will not compile:
```edition2018,compile_fail,E0733
#![feature(async_await)]
async fn foo(n: usize) {
if n > 0 {
foo(n - 1).await;
@ -4763,12 +4762,11 @@ To achieve async recursion, the `async fn` needs to be desugared
such that the `Future` is explicit in the return type:
```edition2018,compile_fail,E0720
# #![feature(async_await)]
use std::future::Future;
fn foo_desugered(n: usize) -> impl Future<Output = ()> {
fn foo_desugared(n: usize) -> impl Future<Output = ()> {
async move {
if n > 0 {
foo_desugered(n - 1).await;
foo_desugared(n - 1).await;
}
}
}
@ -4777,7 +4775,6 @@ fn foo_desugered(n: usize) -> impl Future<Output = ()> {
Finally, the future is wrapped in a pinned box:
```edition2018
# #![feature(async_await)]
use std::future::Future;
use std::pin::Pin;
fn foo_recursive(n: usize) -> Pin<Box<dyn Future<Output = ()>>> {

2
src/libstd/keyword_docs.rs
View file

@ -984,7 +984,6 @@ mod where_keyword { }
// 2018 Edition keywords
#[unstable(feature = "async_await", issue = "50547")]
#[doc(keyword = "async")]
//
/// Return a [`Future`] instead of blocking the current thread.
@ -995,7 +994,6 @@ mod where_keyword { }
/// [not yet complete]: https://github.com/rust-lang/rust/issues/34601
mod async_keyword { }
#[unstable(feature = "async_await", issue = "50547")]
#[doc(keyword = "await")]
//
/// Suspend execution until the result of a [`Future`] is ready.

19
src/libsyntax/feature_gate.rs
View file

@ -461,9 +461,6 @@ declare_features! (
// Allows using `#[doc(keyword = "...")]`.
(active, doc_keyword, "1.28.0", Some(51315), None),
// Allows async and await syntax.
(active, async_await, "1.28.0", Some(50547), None),
// Allows reinterpretation of the bits of a value of one type as another type during const eval.
(active, const_transmute, "1.29.0", Some(53605), None),
@ -857,6 +854,8 @@ declare_features! (
(accepted, repr_align_enum, "1.37.0", Some(57996), None),
// Allows `const _: TYPE = VALUE`.
(accepted, underscore_const_names, "1.37.0", Some(54912), None),
// Allows free and inherent `async fn`s, `async` blocks, and `<expr>.await` expressions.
(accepted, async_await, "1.38.0", Some(50547), None),
// -------------------------------------------------------------------------
// feature-group-end: accepted features
@ -2100,12 +2099,6 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
"labels on blocks are unstable");
}
}
ast::ExprKind::Async(..) => {
gate_feature_post!(&self, async_await, e.span, "async blocks are unstable");
}
ast::ExprKind::Await(_) => {
gate_feature_post!(&self, async_await, e.span, "async/await is unstable");
}
_ => {}
}
visit::walk_expr(self, e)
@ -2154,11 +2147,6 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
span: Span,
_node_id: NodeId) {
if let Some(header) = fn_kind.header() {
// Check for const fn and async fn declarations.
if header.asyncness.node.is_async() {
gate_feature_post!(&self, async_await, span, "async fn is unstable");
}
// Stability of const fn methods are covered in
// `visit_trait_item` and `visit_impl_item` below; this is
// because default methods don't pass through this point.
@ -2198,9 +2186,6 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
if block.is_none() {
self.check_abi(sig.header.abi, ti.span);
}
if sig.header.asyncness.node.is_async() {
gate_feature_post!(&self, async_await, ti.span, "async fn is unstable");
}
if sig.decl.c_variadic {
gate_feature_post!(&self, c_variadic, ti.span,
"C-variadic functions are unstable");

3
src/test/codegen/issue-45222.rs
View file

@ -5,7 +5,6 @@
// verify that LLVM recognizes a loop involving 0..=n and will const-fold it.
//------------------------------------------------------------------------------
// Example from original issue #45222
fn foo2(n: u64) -> u64 {
@ -25,7 +24,6 @@ pub fn check_foo2() -> u64 {
foo2(100000)
}
//------------------------------------------------------------------------------
// Simplified example of #45222
fn triangle_inc(n: u64) -> u64 {
@ -43,7 +41,6 @@ pub fn check_triangle_inc() -> u64 {
triangle_inc(100000)
}
//------------------------------------------------------------------------------
// Demo in #48012
fn foo3r(n: u64) -> u64 {

18
src/test/incremental/hashes/call_expressions.rs
View file

@ -18,7 +18,7 @@ fn callee1(_x: u32, _y: i64) {}
fn callee2(_x: u32, _y: i64) {}
// Change Callee (Function) ----------------------------------------------------
// Change Callee (Function)
#[cfg(cfail1)]
pub fn change_callee_function() {
callee1(1, 2)
@ -33,7 +33,7 @@ pub fn change_callee_function() {
// Change Argument (Function) --------------------------------------------------
// Change Argument (Function)
#[cfg(cfail1)]
pub fn change_argument_function() {
callee1(1, 2)
@ -48,7 +48,7 @@ pub fn change_argument_function() {
// Change Callee Indirectly (Function) -----------------------------------------
// Change Callee Indirectly (Function)
mod change_callee_indirectly_function {
#[cfg(cfail1)]
use super::callee1 as callee;
@ -73,7 +73,7 @@ impl Struct {
fn method2(&self, _x: char, _y: bool) {}
}
// Change Callee (Method) ------------------------------------------------------
// Change Callee (Method)
#[cfg(cfail1)]
pub fn change_callee_method() {
let s = Struct;
@ -90,7 +90,7 @@ pub fn change_callee_method() {
// Change Argument (Method) ----------------------------------------------------
// Change Argument (Method)
#[cfg(cfail1)]
pub fn change_argument_method() {
let s = Struct;
@ -107,7 +107,7 @@ pub fn change_argument_method() {
// Change Callee (Method, UFCS) ------------------------------------------------
// Change Callee (Method, UFCS)
#[cfg(cfail1)]
pub fn change_ufcs_callee_method() {
let s = Struct;
@ -124,7 +124,7 @@ pub fn change_ufcs_callee_method() {
// Change Argument (Method, UFCS) ----------------------------------------------
// Change Argument (Method, UFCS)
#[cfg(cfail1)]
pub fn change_argument_method_ufcs() {
let s = Struct;
@ -141,7 +141,7 @@ pub fn change_argument_method_ufcs() {
// Change To UFCS --------------------------------------------------------------
// Change To UFCS
#[cfg(cfail1)]
pub fn change_to_ufcs() {
let s = Struct;
@ -164,7 +164,7 @@ impl Struct2 {
fn method1(&self, _x: char, _y: bool) {}
}
// Change UFCS Callee Indirectly -----------------------------------------------
// Change UFCS Callee Indirectly
pub mod change_ufcs_callee_indirectly {
#[cfg(cfail1)]
use super::Struct as Struct;

12
src/test/incremental/hashes/closure_expressions.rs
View file

@ -14,7 +14,7 @@
#![crate_type="rlib"]
// Change closure body ---------------------------------------------------------
// Change closure body
#[cfg(cfail1)]
pub fn change_closure_body() {
let _ = || 1u32;
@ -29,7 +29,7 @@ pub fn change_closure_body() {
// Add parameter ---------------------------------------------------------------
// Add parameter
#[cfg(cfail1)]
pub fn add_parameter() {
let x = 0u32;
@ -46,7 +46,7 @@ pub fn add_parameter() {
// Change parameter pattern ----------------------------------------------------
// Change parameter pattern
#[cfg(cfail1)]
pub fn change_parameter_pattern() {
let _ = |x: (u32,)| x;
@ -61,7 +61,7 @@ pub fn change_parameter_pattern() {
// Add `move` to closure -------------------------------------------------------
// Add `move` to closure
#[cfg(cfail1)]
pub fn add_move() {
let _ = || 1;
@ -76,7 +76,7 @@ pub fn add_move() {
// Add type ascription to parameter --------------------------------------------
// Add type ascription to parameter
#[cfg(cfail1)]
pub fn add_type_ascription_to_parameter() {
let closure = |x| x + 1u32;
@ -93,7 +93,7 @@ pub fn add_type_ascription_to_parameter() {
// Change parameter type -------------------------------------------------------
// Change parameter type
#[cfg(cfail1)]
pub fn change_parameter_type() {
let closure = |x: u32| (x as u64) + 1;

12
src/test/incremental/hashes/consts.rs
View file

@ -14,7 +14,7 @@
#![crate_type="rlib"]
// Change const visibility ---------------------------------------------------
// Change const visibility
#[cfg(cfail1)]
const CONST_VISIBILITY: u8 = 0;
@ -24,7 +24,7 @@ const CONST_VISIBILITY: u8 = 0;
pub const CONST_VISIBILITY: u8 = 0;
// Change type from i32 to u32 ------------------------------------------------
// Change type from i32 to u32
#[cfg(cfail1)]
const CONST_CHANGE_TYPE_1: i32 = 0;
@ -34,7 +34,7 @@ const CONST_CHANGE_TYPE_1: i32 = 0;
const CONST_CHANGE_TYPE_1: u32 = 0;
// Change type from Option<u32> to Option<u64> --------------------------------
// Change type from Option<u32> to Option<u64>
#[cfg(cfail1)]
const CONST_CHANGE_TYPE_2: Option<u32> = None;
@ -44,7 +44,7 @@ const CONST_CHANGE_TYPE_2: Option<u32> = None;
const CONST_CHANGE_TYPE_2: Option<u64> = None;
// Change value between simple literals ---------------------------------------
// Change value between simple literals
#[rustc_clean(cfg="cfail2", except="HirBody")]
#[rustc_clean(cfg="cfail3")]
const CONST_CHANGE_VALUE_1: i16 = {
@ -56,7 +56,7 @@ const CONST_CHANGE_VALUE_1: i16 = {
};
// Change value between expressions -------------------------------------------
// Change value between expressions
#[rustc_clean(cfg="cfail2", except="HirBody")]
#[rustc_clean(cfg="cfail3")]
const CONST_CHANGE_VALUE_2: i16 = {
@ -88,7 +88,7 @@ const CONST_CHANGE_VALUE_4: i16 = {
};
// Change type indirectly -----------------------------------------------------
// Change type indirectly
struct ReferencedType1;
struct ReferencedType2;

16
src/test/incremental/hashes/if_expressions.rs
View file

@ -14,7 +14,7 @@
#![feature(rustc_attrs)]
#![crate_type="rlib"]
// Change condition (if) -------------------------------------------------------
// Change condition (if)
#[cfg(cfail1)]
pub fn change_condition(x: bool) -> u32 {
if x {
@ -35,7 +35,7 @@ pub fn change_condition(x: bool) -> u32 {
return 0
}
// Change then branch (if) -----------------------------------------------------
// Change then branch (if)
#[cfg(cfail1)]
pub fn change_then_branch(x: bool) -> u32 {
if x {
@ -58,7 +58,7 @@ pub fn change_then_branch(x: bool) -> u32 {
// Change else branch (if) -----------------------------------------------------
// Change else branch (if)
#[cfg(cfail1)]
pub fn change_else_branch(x: bool) -> u32 {
if x {
@ -81,7 +81,7 @@ pub fn change_else_branch(x: bool) -> u32 {
// Add else branch (if) --------------------------------------------------------
// Add else branch (if)
#[cfg(cfail1)]
pub fn add_else_branch(x: bool) -> u32 {
let mut ret = 1;
@ -109,7 +109,7 @@ pub fn add_else_branch(x: bool) -> u32 {
// Change condition (if let) ---------------------------------------------------
// Change condition (if let)
#[cfg(cfail1)]
pub fn change_condition_if_let(x: Option<u32>) -> u32 {
if let Some(_x) = x {
@ -132,7 +132,7 @@ pub fn change_condition_if_let(x: Option<u32>) -> u32 {
// Change then branch (if let) -------------------------------------------------
// Change then branch (if let)
#[cfg(cfail1)]
pub fn change_then_branch_if_let(x: Option<u32>) -> u32 {
if let Some(x) = x {
@ -155,7 +155,7 @@ pub fn change_then_branch_if_let(x: Option<u32>) -> u32 {
// Change else branch (if let) -------------------------------------------------
// Change else branch (if let)
#[cfg(cfail1)]
pub fn change_else_branch_if_let(x: Option<u32>) -> u32 {
if let Some(x) = x {
@ -178,7 +178,7 @@ pub fn change_else_branch_if_let(x: Option<u32>) -> u32 {
// Add else branch (if let) ----------------------------------------------------
// Add else branch (if let)
#[cfg(cfail1)]
pub fn add_else_branch_if_let(x: Option<u32>) -> u32 {
let mut ret = 1;

14
src/test/incremental/hashes/indexing_expressions.rs
View file

@ -13,7 +13,7 @@
#![feature(rustc_attrs)]
#![crate_type="rlib"]
// Change simple index ---------------------------------------------------------
// Change simple index
#[cfg(cfail1)]
fn change_simple_index(slice: &[u32]) -> u32 {
slice[3]
@ -30,7 +30,7 @@ fn change_simple_index(slice: &[u32]) -> u32 {
// Change lower bound ----------------------------------------------------------
// Change lower bound
#[cfg(cfail1)]
fn change_lower_bound(slice: &[u32]) -> &[u32] {
&slice[3..5]
@ -47,7 +47,7 @@ fn change_lower_bound(slice: &[u32]) -> &[u32] {
// Change upper bound ----------------------------------------------------------
// Change upper bound
#[cfg(cfail1)]
fn change_upper_bound(slice: &[u32]) -> &[u32] {
&slice[3..5]
@ -64,7 +64,7 @@ fn change_upper_bound(slice: &[u32]) -> &[u32] {
// Add lower bound -------------------------------------------------------------
// Add lower bound
#[cfg(cfail1)]
fn add_lower_bound(slice: &[u32]) -> &[u32] {
&slice[..4]
@ -81,7 +81,7 @@ fn add_lower_bound(slice: &[u32]) -> &[u32] {
// Add upper bound -------------------------------------------------------------
// Add upper bound
#[cfg(cfail1)]
fn add_upper_bound(slice: &[u32]) -> &[u32] {
&slice[3..]
@ -98,7 +98,7 @@ fn add_upper_bound(slice: &[u32]) -> &[u32] {
// Change mutability -----------------------------------------------------------
// Change mutability
#[cfg(cfail1)]
fn change_mutability(slice: &mut [u32]) -> u32 {
(&mut slice[3..5])[0]
@ -115,7 +115,7 @@ fn change_mutability(slice: &mut [u32]) -> u32 {
// Exclusive to inclusive range ------------------------------------------------
// Exclusive to inclusive range
#[cfg(cfail1)]
fn exclusive_to_inclusive_range(slice: &[u32]) -> &[u32] {
&slice[3..7]

12
src/test/incremental/hashes/inline_asm.rs
View file

@ -16,7 +16,7 @@
// Change template -------------------------------------------------------------
// Change template
#[cfg(cfail1)]
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
pub fn change_template(a: i32) -> i32 {
@ -51,7 +51,7 @@ pub fn change_template(a: i32) -> i32 {
// Change output -------------------------------------------------------------
// Change output
#[cfg(cfail1)]
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
pub fn change_output(a: i32) -> i32 {
@ -88,7 +88,7 @@ pub fn change_output(a: i32) -> i32 {
// Change input -------------------------------------------------------------
// Change input
#[cfg(cfail1)]
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
pub fn change_input(_a: i32, _b: i32) -> i32 {
@ -123,7 +123,7 @@ pub fn change_input(_a: i32, _b: i32) -> i32 {
// Change input constraint -----------------------------------------------------
// Change input constraint
#[cfg(cfail1)]
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
pub fn change_input_constraint(_a: i32, _b: i32) -> i32 {
@ -158,7 +158,7 @@ pub fn change_input_constraint(_a: i32, _b: i32) -> i32 {
// Change clobber --------------------------------------------------------------
// Change clobber
#[cfg(cfail1)]
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
pub fn change_clobber(_a: i32) -> i32 {
@ -193,7 +193,7 @@ pub fn change_clobber(_a: i32) -> i32 {
// Change options --------------------------------------------------------------
// Change options
#[cfg(cfail1)]
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
pub fn change_options(_a: i32) -> i32 {

16
src/test/incremental/hashes/loop_expressions.rs
View file

@ -14,7 +14,7 @@
#![crate_type="rlib"]
// Change loop body ------------------------------------------------------------
// Change loop body
#[cfg(cfail1)]
pub fn change_loop_body() {
let mut _x = 0;
@ -37,7 +37,7 @@ pub fn change_loop_body() {
// Add break -------------------------------------------------------------------
// Add break
#[cfg(cfail1)]
pub fn add_break() {
let mut _x = 0;
@ -59,7 +59,7 @@ pub fn add_break() {
// Add loop label --------------------------------------------------------------
// Add loop label
#[cfg(cfail1)]
pub fn add_loop_label() {
let mut _x = 0;
@ -82,7 +82,7 @@ pub fn add_loop_label() {
// Add loop label to break -----------------------------------------------------
// Add loop label to break
#[cfg(cfail1)]
pub fn add_loop_label_to_break() {
let mut _x = 0;
@ -105,7 +105,7 @@ pub fn add_loop_label_to_break() {
// Change break label ----------------------------------------------------------
// Change break label
#[cfg(cfail1)]
pub fn change_break_label() {
let mut _x = 0;
@ -132,7 +132,7 @@ pub fn change_break_label() {
// Add loop label to continue --------------------------------------------------
// Add loop label to continue
#[cfg(cfail1)]
pub fn add_loop_label_to_continue() {
let mut _x = 0;
@ -155,7 +155,7 @@ pub fn add_loop_label_to_continue() {
// Change continue label ----------------------------------------------------------
// Change continue label
#[cfg(cfail1)]
pub fn change_continue_label() {
let mut _x = 0;
@ -182,7 +182,7 @@ pub fn change_continue_label() {
// Change continue to break ----------------------------------------------------
// Change continue to break
#[cfg(cfail1)]
pub fn change_continue_to_break() {
let mut _x = 0;

18
src/test/incremental/hashes/panic_exprs.rs
View file

@ -17,7 +17,7 @@
#![crate_type="rlib"]
// Indexing expression ---------------------------------------------------------
// Indexing expression
#[rustc_clean(cfg="cfail2", except="HirBody,mir_built,optimized_mir")]
#[rustc_clean(cfg="cfail3")]
pub fn indexing(slice: &[u8]) -> u8 {
@ -32,7 +32,7 @@ pub fn indexing(slice: &[u8]) -> u8 {
}
// Arithmetic overflow plus ----------------------------------------------------
// Arithmetic overflow plus
#[rustc_clean(cfg="cfail2", except="HirBody,mir_built,optimized_mir")]
#[rustc_clean(cfg="cfail3")]
pub fn arithmetic_overflow_plus(val: i32) -> i32 {
@ -47,7 +47,7 @@ pub fn arithmetic_overflow_plus(val: i32) -> i32 {
}
// Arithmetic overflow minus ----------------------------------------------------
// Arithmetic overflow minus
#[rustc_clean(cfg="cfail2", except="HirBody,mir_built,optimized_mir")]
#[rustc_clean(cfg="cfail3")]
pub fn arithmetic_overflow_minus(val: i32) -> i32 {
@ -62,7 +62,7 @@ pub fn arithmetic_overflow_minus(val: i32) -> i32 {
}
// Arithmetic overflow mult ----------------------------------------------------
// Arithmetic overflow mult
#[rustc_clean(cfg="cfail2", except="HirBody,mir_built,optimized_mir")]
#[rustc_clean(cfg="cfail3")]
pub fn arithmetic_overflow_mult(val: i32) -> i32 {
@ -77,7 +77,7 @@ pub fn arithmetic_overflow_mult(val: i32) -> i32 {
}
// Arithmetic overflow negation ------------------------------------------------
// Arithmetic overflow negation
#[rustc_clean(cfg="cfail2", except="HirBody,mir_built,optimized_mir")]
#[rustc_clean(cfg="cfail3")]
pub fn arithmetic_overflow_negation(val: i32) -> i32 {
@ -92,7 +92,7 @@ pub fn arithmetic_overflow_negation(val: i32) -> i32 {
}
// Division by zero ------------------------------------------------------------
// Division by zero
#[rustc_clean(cfg="cfail2", except="HirBody,mir_built,optimized_mir")]
#[rustc_clean(cfg="cfail3")]
pub fn division_by_zero(val: i32) -> i32 {
@ -106,7 +106,7 @@ pub fn division_by_zero(val: i32) -> i32 {
}
}
// Division by zero ------------------------------------------------------------
// Division by zero
#[rustc_clean(cfg="cfail2", except="HirBody,mir_built,optimized_mir")]
#[rustc_clean(cfg="cfail3")]
pub fn mod_by_zero(val: i32) -> i32 {
@ -121,7 +121,7 @@ pub fn mod_by_zero(val: i32) -> i32 {
}
// shift left ------------------------------------------------------------------
// shift left
#[rustc_clean(cfg="cfail2", except="HirBody,mir_built,optimized_mir")]
#[rustc_clean(cfg="cfail3")]
pub fn shift_left(val: i32, shift: usize) -> i32 {
@ -136,7 +136,7 @@ pub fn shift_left(val: i32, shift: usize) -> i32 {
}
// shift right ------------------------------------------------------------------
// shift right
#[rustc_clean(cfg="cfail2", except="HirBody,mir_built,optimized_mir")]
#[rustc_clean(cfg="cfail3")]
pub fn shift_right(val: i32, shift: usize) -> i32 {

20
src/test/incremental/hashes/statics.rs
View file

@ -16,7 +16,7 @@
#![crate_type="rlib"]
// Change static visibility ---------------------------------------------------
// Change static visibility
#[cfg(cfail1)]
static STATIC_VISIBILITY: u8 = 0;
@ -26,7 +26,7 @@ static STATIC_VISIBILITY: u8 = 0;
pub static STATIC_VISIBILITY: u8 = 0;
// Change static mutability ---------------------------------------------------
// Change static mutability
#[cfg(cfail1)]
static STATIC_MUTABILITY: u8 = 0;
@ -36,7 +36,7 @@ static STATIC_MUTABILITY: u8 = 0;
static mut STATIC_MUTABILITY: u8 = 0;
// Add linkage attribute ------------------------------------------------------
// Add linkage attribute
#[cfg(cfail1)]
static STATIC_LINKAGE: u8 = 0;
@ -47,7 +47,7 @@ static STATIC_LINKAGE: u8 = 0;
static STATIC_LINKAGE: u8 = 0;
// Add no_mangle attribute ----------------------------------------------------
// Add no_mangle attribute
#[cfg(cfail1)]
static STATIC_NO_MANGLE: u8 = 0;
@ -58,7 +58,7 @@ static STATIC_NO_MANGLE: u8 = 0;
static STATIC_NO_MANGLE: u8 = 0;
// Add thread_local attribute -------------------------------------------------
// Add thread_local attribute
#[cfg(cfail1)]
static STATIC_THREAD_LOCAL: u8 = 0;
@ -69,7 +69,7 @@ static STATIC_THREAD_LOCAL: u8 = 0;
static STATIC_THREAD_LOCAL: u8 = 0;
// Change type from i16 to u64 ------------------------------------------------
// Change type from i16 to u64
#[cfg(cfail1)]
static STATIC_CHANGE_TYPE_1: i16 = 0;
@ -79,7 +79,7 @@ static STATIC_CHANGE_TYPE_1: i16 = 0;
static STATIC_CHANGE_TYPE_1: u64 = 0;
// Change type from Option<i8> to Option<u16> ---------------------------------
// Change type from Option<i8> to Option<u16>
#[cfg(cfail1)]
static STATIC_CHANGE_TYPE_2: Option<i8> = None;
@ -89,7 +89,7 @@ static STATIC_CHANGE_TYPE_2: Option<i8> = None;
static STATIC_CHANGE_TYPE_2: Option<u16> = None;
// Change value between simple literals ---------------------------------------
// Change value between simple literals
#[rustc_clean(cfg="cfail2", except="HirBody")]
#[rustc_clean(cfg="cfail3")]
static STATIC_CHANGE_VALUE_1: i16 = {
@ -101,7 +101,7 @@ static STATIC_CHANGE_VALUE_1: i16 = {
};
// Change value between expressions -------------------------------------------
// Change value between expressions
#[rustc_clean(cfg="cfail2", except="HirBody")]
#[rustc_clean(cfg="cfail3")]
static STATIC_CHANGE_VALUE_2: i16 = {
@ -133,7 +133,7 @@ static STATIC_CHANGE_VALUE_4: i16 = {
};
// Change type indirectly -----------------------------------------------------
// Change type indirectly
struct ReferencedType1;
struct ReferencedType2;

18
src/test/incremental/hashes/struct_constructors.rs
View file

@ -20,7 +20,7 @@ pub struct RegularStruct {
z: i16,
}
// Change field value (regular struct) -----------------------------------------
// Change field value (regular struct)
#[cfg(cfail1)]
pub fn change_field_value_regular_struct() -> RegularStruct {
RegularStruct {
@ -43,7 +43,7 @@ pub fn change_field_value_regular_struct() -> RegularStruct {
// Change field order (regular struct) -----------------------------------------
// Change field order (regular struct)
#[cfg(cfail1)]
pub fn change_field_order_regular_struct() -> RegularStruct {
RegularStruct {
@ -66,7 +66,7 @@ pub fn change_field_order_regular_struct() -> RegularStruct {
// Add field (regular struct) --------------------------------------------------
// Add field (regular struct)
#[cfg(cfail1)]
pub fn add_field_regular_struct() -> RegularStruct {
let struct1 = RegularStruct {
@ -100,7 +100,7 @@ pub fn add_field_regular_struct() -> RegularStruct {
// Change field label (regular struct) -----------------------------------------
// Change field label (regular struct)
#[cfg(cfail1)]
pub fn change_field_label_regular_struct() -> RegularStruct {
let struct1 = RegularStruct {
@ -141,7 +141,7 @@ pub struct RegularStruct2 {
z: i8,
}
// Change constructor path (regular struct) ------------------------------------
// Change constructor path (regular struct)
#[cfg(cfail1)]
pub fn change_constructor_path_regular_struct() {
let _ = RegularStruct {
@ -164,7 +164,7 @@ pub fn change_constructor_path_regular_struct() {
// Change constructor path indirectly (regular struct) -------------------------
// Change constructor path indirectly (regular struct)
pub mod change_constructor_path_indirectly_regular_struct {
#[cfg(cfail1)]
use super::RegularStruct as Struct;
@ -189,7 +189,7 @@ pub mod change_constructor_path_indirectly_regular_struct {
pub struct TupleStruct(i32, i64, i16);
// Change field value (tuple struct) -------------------------------------------
// Change field value (tuple struct)
#[cfg(cfail1)]
pub fn change_field_value_tuple_struct() -> TupleStruct {
TupleStruct(0, 1, 2)
@ -206,7 +206,7 @@ pub fn change_field_value_tuple_struct() -> TupleStruct {
pub struct TupleStruct2(u16, u16, u16);
// Change constructor path (tuple struct) --------------------------------------
// Change constructor path (tuple struct)
#[cfg(cfail1)]
pub fn change_constructor_path_tuple_struct() {
let _ = TupleStruct(0, 1, 2);
@ -221,7 +221,7 @@ pub fn change_constructor_path_tuple_struct() {
// Change constructor path indirectly (tuple struct) ---------------------------
// Change constructor path indirectly (tuple struct)
pub mod change_constructor_path_indirectly_tuple_struct {
#[cfg(cfail1)]
use super::TupleStruct as Struct;

121
src/test/incremental/hashes/trait_defs.rs
View file

@ -21,7 +21,7 @@
#![feature(intrinsics)]
// Change trait visibility --------------------------------------------------------
// Change trait visibility
#[cfg(cfail1)]
trait TraitVisibility { }
@ -32,7 +32,7 @@ pub trait TraitVisibility { }
// Change trait unsafety ----------------------------------------------------------
// Change trait unsafety
#[cfg(cfail1)]
trait TraitUnsafety { }
@ -43,7 +43,7 @@ unsafe trait TraitUnsafety { }
// Add method ---------------------------------------------------------------------
// Add method
#[cfg(cfail1)]
trait TraitAddMethod {
}
@ -57,7 +57,7 @@ pub trait TraitAddMethod {
// Change name of method ----------------------------------------------------------
// Change name of method
#[cfg(cfail1)]
trait TraitChangeMethodName {
fn method();
@ -72,7 +72,7 @@ trait TraitChangeMethodName {
// Add return type to method ------------------------------------------------------
// Add return type to method
#[cfg(cfail1)]
trait TraitAddReturnType {
fn method();
@ -89,7 +89,7 @@ trait TraitAddReturnType {
// Change return type of method ---------------------------------------------------
// Change return type of method
#[cfg(cfail1)]
trait TraitChangeReturnType {
fn method() -> u32;
@ -106,7 +106,7 @@ trait TraitChangeReturnType {
// Add parameter to method --------------------------------------------------------
// Add parameter to method
#[cfg(cfail1)]
trait TraitAddParameterToMethod {
fn method();
@ -123,7 +123,7 @@ trait TraitAddParameterToMethod {
// Change name of method parameter ------------------------------------------------
// Change name of method parameter
#[cfg(cfail1)]
trait TraitChangeMethodParameterName {
fn method(a: u32);
@ -148,7 +148,7 @@ trait TraitChangeMethodParameterName {
// Change type of method parameter (i32 => i64) -----------------------------------
// Change type of method parameter (i32 => i64)
#[cfg(cfail1)]
trait TraitChangeMethodParameterType {
fn method(a: i32);
@ -165,7 +165,7 @@ trait TraitChangeMethodParameterType {
// Change type of method parameter (&i32 => &mut i32) -----------------------------
// Change type of method parameter (&i32 => &mut i32)
#[cfg(cfail1)]
trait TraitChangeMethodParameterTypeRef {
fn method(a: &i32);
@ -182,7 +182,7 @@ trait TraitChangeMethodParameterTypeRef {
// Change order of method parameters ----------------------------------------------
// Change order of method parameters
#[cfg(cfail1)]
trait TraitChangeMethodParametersOrder {
fn method(a: i32, b: i64);
@ -199,7 +199,7 @@ trait TraitChangeMethodParametersOrder {
// Add default implementation to method -------------------------------------------
// Add default implementation to method
#[cfg(cfail1)]
trait TraitAddMethodAutoImplementation {
fn method();
@ -216,7 +216,7 @@ trait TraitAddMethodAutoImplementation {
// Change order of methods --------------------------------------------------------
// Change order of methods
#[cfg(cfail1)]
trait TraitChangeOrderOfMethods {
fn method0();
@ -233,7 +233,7 @@ trait TraitChangeOrderOfMethods {
// Change mode of self parameter --------------------------------------------------
// Change mode of self parameter
#[cfg(cfail1)]
trait TraitChangeModeSelfRefToMut {
fn method(&self);
@ -284,7 +284,7 @@ trait TraitChangeModeSelfOwnToRef {
// Add unsafe modifier to method --------------------------------------------------
// Add unsafe modifier to method
#[cfg(cfail1)]
trait TraitAddUnsafeModifier {
fn method();
@ -301,7 +301,7 @@ trait TraitAddUnsafeModifier {
// Add extern modifier to method --------------------------------------------------
// Add extern modifier to method
#[cfg(cfail1)]
trait TraitAddExternModifier {
fn method();
@ -318,7 +318,7 @@ trait TraitAddExternModifier {
// Change extern "C" to extern "rust-intrinsic" -----------------------------------
// Change extern "C" to extern "rust-intrinsic"
#[cfg(cfail1)]
trait TraitChangeExternCToRustIntrinsic {
extern "C" fn method();
@ -335,7 +335,7 @@ trait TraitChangeExternCToRustIntrinsic {
// Add type parameter to method ---------------------------------------------------
// Add type parameter to method
#[cfg(cfail1)]
trait TraitAddTypeParameterToMethod {
fn method();
@ -352,7 +352,7 @@ trait TraitAddTypeParameterToMethod {
// Add lifetime parameter to method -----------------------------------------------
// Add lifetime parameter to method
#[cfg(cfail1)]
trait TraitAddLifetimeParameterToMethod {
fn method();
@ -373,7 +373,7 @@ trait TraitAddLifetimeParameterToMethod {
trait ReferencedTrait0 { }
trait ReferencedTrait1 { }
// Add trait bound to method type parameter ---------------------------------------
// Add trait bound to method type parameter
#[cfg(cfail1)]
trait TraitAddTraitBoundToMethodTypeParameter {
fn method<T>();
@ -390,7 +390,7 @@ trait TraitAddTraitBoundToMethodTypeParameter {
// Add builtin bound to method type parameter -------------------------------------
// Add builtin bound to method type parameter
#[cfg(cfail1)]
trait TraitAddBuiltinBoundToMethodTypeParameter {
fn method<T>();
@ -407,7 +407,7 @@ trait TraitAddBuiltinBoundToMethodTypeParameter {
// Add lifetime bound to method lifetime parameter ------------------------------------
// Add lifetime bound to method lifetime parameter
#[cfg(cfail1)]
trait TraitAddLifetimeBoundToMethodLifetimeParameter {
fn method<'a, 'b>(a: &'a u32, b: &'b u32);
@ -424,7 +424,7 @@ trait TraitAddLifetimeBoundToMethodLifetimeParameter {
// Add second trait bound to method type parameter --------------------------------
// Add second trait bound to method type parameter
#[cfg(cfail1)]
trait TraitAddSecondTraitBoundToMethodTypeParameter {
fn method<T: ReferencedTrait0>();
@ -441,7 +441,7 @@ trait TraitAddSecondTraitBoundToMethodTypeParameter {
// Add second builtin bound to method type parameter ------------------------------
// Add second builtin bound to method type parameter
#[cfg(cfail1)]
trait TraitAddSecondBuiltinBoundToMethodTypeParameter {
fn method<T: Sized>();
@ -458,7 +458,7 @@ trait TraitAddSecondBuiltinBoundToMethodTypeParameter {
// Add second lifetime bound to method lifetime parameter -----------------------------
// Add second lifetime bound to method lifetime parameter
#[cfg(cfail1)]
trait TraitAddSecondLifetimeBoundToMethodLifetimeParameter {
fn method<'a, 'b, 'c: 'a>(a: &'a u32, b: &'b u32, c: &'c u32);
@ -475,7 +475,7 @@ trait TraitAddSecondLifetimeBoundToMethodLifetimeParameter {
// Add associated type ------------------------------------------------------------
// Add associated type
#[cfg(cfail1)]
trait TraitAddAssociatedType {
@ -495,7 +495,7 @@ trait TraitAddAssociatedType {
// Add trait bound to associated type ---------------------------------------------
// Add trait bound to associated type
#[cfg(cfail1)]
trait TraitAddTraitBoundToAssociatedType {
type Associated;
@ -519,7 +519,7 @@ trait TraitAddTraitBoundToAssociatedType {
// Add lifetime bound to associated type ------------------------------------------
// Add lifetime bound to associated type
#[cfg(cfail1)]
trait TraitAddLifetimeBoundToAssociatedType<'a> {
type Associated;
@ -540,7 +540,7 @@ trait TraitAddLifetimeBoundToAssociatedType<'a> {
// Add default to associated type -------------------------------------------------
// Add default to associated type
#[cfg(cfail1)]
trait TraitAddDefaultToAssociatedType {
type Associated;
@ -561,7 +561,7 @@ trait TraitAddDefaultToAssociatedType {
// Add associated constant --------------------------------------------------------
// Add associated constant
#[cfg(cfail1)]
trait TraitAddAssociatedConstant {
fn method();
@ -578,7 +578,7 @@ trait TraitAddAssociatedConstant {
// Add initializer to associated constant -----------------------------------------
// Add initializer to associated constant
#[cfg(cfail1)]
trait TraitAddInitializerToAssociatedConstant {
const Value: u32;
@ -601,7 +601,7 @@ trait TraitAddInitializerToAssociatedConstant {
// Change type of associated constant ---------------------------------------------
// Change type of associated constant
#[cfg(cfail1)]
trait TraitChangeTypeOfAssociatedConstant {
const Value: u32;
@ -624,7 +624,7 @@ trait TraitChangeTypeOfAssociatedConstant {
// Add super trait ----------------------------------------------------------------
// Add super trait
#[cfg(cfail1)]
trait TraitAddSuperTrait { }
@ -635,7 +635,7 @@ trait TraitAddSuperTrait : ReferencedTrait0 { }
// Add builtin bound (Send or Copy) -----------------------------------------------
// Add builtin bound (Send or Copy)
#[cfg(cfail1)]
trait TraitAddBuiltiBound { }
@ -646,7 +646,7 @@ trait TraitAddBuiltiBound : Send { }
// Add 'static lifetime bound to trait --------------------------------------------
// Add 'static lifetime bound to trait
#[cfg(cfail1)]
trait TraitAddStaticLifetimeBound { }
@ -657,7 +657,7 @@ trait TraitAddStaticLifetimeBound : 'static { }
// Add super trait as second bound ------------------------------------------------
// Add super trait as second bound
#[cfg(cfail1)]
trait TraitAddTraitAsSecondBound : ReferencedTrait0 { }
@ -676,7 +676,7 @@ trait TraitAddTraitAsSecondBoundFromBuiltin : Send + ReferencedTrait0 { }
// Add builtin bound as second bound ----------------------------------------------
// Add builtin bound as second bound
#[cfg(cfail1)]
trait TraitAddBuiltinBoundAsSecondBound : ReferencedTrait0 { }
@ -695,7 +695,7 @@ trait TraitAddBuiltinBoundAsSecondBoundFromBuiltin: Send + Copy { }
// Add 'static bounds as second bound ---------------------------------------------
// Add 'static bounds as second bound
#[cfg(cfail1)]
trait TraitAddStaticBoundAsSecondBound : ReferencedTrait0 { }
@ -714,7 +714,7 @@ trait TraitAddStaticBoundAsSecondBoundFromBuiltin : Send + 'static { }
// Add type parameter to trait ----------------------------------------------------
// Add type parameter to trait
#[cfg(cfail1)]
trait TraitAddTypeParameterToTrait { }
@ -725,7 +725,7 @@ trait TraitAddTypeParameterToTrait<T> { }
// Add lifetime parameter to trait ------------------------------------------------
// Add lifetime parameter to trait
#[cfg(cfail1)]
trait TraitAddLifetimeParameterToTrait { }
@ -736,7 +736,7 @@ trait TraitAddLifetimeParameterToTrait<'a> { }
// Add trait bound to type parameter of trait -------------------------------------
// Add trait bound to type parameter of trait
#[cfg(cfail1)]
trait TraitAddTraitBoundToTypeParameterOfTrait<T> { }
@ -747,7 +747,7 @@ trait TraitAddTraitBoundToTypeParameterOfTrait<T: ReferencedTrait0> { }
// Add lifetime bound to type parameter of trait ----------------------------------
// Add lifetime bound to type parameter of trait
#[cfg(cfail1)]
trait TraitAddLifetimeBoundToTypeParameterOfTrait<'a, T> { }
@ -758,7 +758,7 @@ trait TraitAddLifetimeBoundToTypeParameterOfTrait<'a, T: 'a> { }
// Add lifetime bound to lifetime parameter of trait ------------------------------
// Add lifetime bound to lifetime parameter of trait
#[cfg(cfail1)]
trait TraitAddLifetimeBoundToLifetimeParameterOfTrait<'a, 'b> { }
@ -769,7 +769,7 @@ trait TraitAddLifetimeBoundToLifetimeParameterOfTrait<'a: 'b, 'b> { }
// Add builtin bound to type parameter of trait -----------------------------------
// Add builtin bound to type parameter of trait
#[cfg(cfail1)]
trait TraitAddBuiltinBoundToTypeParameterOfTrait<T> { }
@ -780,7 +780,7 @@ trait TraitAddBuiltinBoundToTypeParameterOfTrait<T: Send> { }
// Add second type parameter to trait ---------------------------------------------
// Add second type parameter to trait
#[cfg(cfail1)]
trait TraitAddSecondTypeParameterToTrait<T> { }
@ -791,7 +791,7 @@ trait TraitAddSecondTypeParameterToTrait<T, S> { }
// Add second lifetime parameter to trait -----------------------------------------
// Add second lifetime parameter to trait
#[cfg(cfail1)]
trait TraitAddSecondLifetimeParameterToTrait<'a> { }
@ -802,7 +802,7 @@ trait TraitAddSecondLifetimeParameterToTrait<'a, 'b> { }
// Add second trait bound to type parameter of trait ------------------------------
// Add second trait bound to type parameter of trait
#[cfg(cfail1)]
trait TraitAddSecondTraitBoundToTypeParameterOfTrait<T: ReferencedTrait0> { }
@ -813,7 +813,7 @@ trait TraitAddSecondTraitBoundToTypeParameterOfTrait<T: ReferencedTrait0 + Refer
// Add second lifetime bound to type parameter of trait ---------------------------
// Add second lifetime bound to type parameter of trait
#[cfg(cfail1)]
trait TraitAddSecondLifetimeBoundToTypeParameterOfTrait<'a, 'b, T: 'a> { }
@ -824,7 +824,7 @@ trait TraitAddSecondLifetimeBoundToTypeParameterOfTrait<'a, 'b, T: 'a + 'b> { }
// Add second lifetime bound to lifetime parameter of trait------------------------
// Add second lifetime bound to lifetime parameter of trait
#[cfg(cfail1)]
trait TraitAddSecondLifetimeBoundToLifetimeParameterOfTrait<'a: 'b, 'b, 'c> { }
@ -835,7 +835,7 @@ trait TraitAddSecondLifetimeBoundToLifetimeParameterOfTrait<'a: 'b + 'c, 'b, 'c>
// Add second builtin bound to type parameter of trait ----------------------------
// Add second builtin bound to type parameter of trait
#[cfg(cfail1)]
trait TraitAddSecondBuiltinBoundToTypeParameterOfTrait<T: Send> { }
@ -846,13 +846,12 @@ trait TraitAddSecondBuiltinBoundToTypeParameterOfTrait<T: Send + Sync> { }
// --------------------------------------------------------------------------------
struct ReferenceType0 {}
struct ReferenceType1 {}
// Add trait bound to type parameter of trait in where clause----------------------
// Add trait bound to type parameter of trait in where clause
#[cfg(cfail1)]
trait TraitAddTraitBoundToTypeParameterOfTraitWhere<T> { }
@ -863,7 +862,7 @@ trait TraitAddTraitBoundToTypeParameterOfTraitWhere<T> where T: ReferencedTrait0
// Add lifetime bound to type parameter of trait in where clause-------------------
// Add lifetime bound to type parameter of trait in where clause
#[cfg(cfail1)]
trait TraitAddLifetimeBoundToTypeParameterOfTraitWhere<'a, T> { }
@ -874,7 +873,7 @@ trait TraitAddLifetimeBoundToTypeParameterOfTraitWhere<'a, T> where T: 'a { }
// Add lifetime bound to lifetime parameter of trait in where clause---------------
// Add lifetime bound to lifetime parameter of trait in where clause
#[cfg(cfail1)]
trait TraitAddLifetimeBoundToLifetimeParameterOfTraitWhere<'a, 'b> { }
@ -885,7 +884,7 @@ trait TraitAddLifetimeBoundToLifetimeParameterOfTraitWhere<'a, 'b> where 'a: 'b
// Add builtin bound to type parameter of trait in where clause--------------------
// Add builtin bound to type parameter of trait in where clause
#[cfg(cfail1)]
trait TraitAddBuiltinBoundToTypeParameterOfTraitWhere<T> { }
@ -896,7 +895,7 @@ trait TraitAddBuiltinBoundToTypeParameterOfTraitWhere<T> where T: Send { }
// Add second trait bound to type parameter of trait in where clause---------------
// Add second trait bound to type parameter of trait in where clause
#[cfg(cfail1)]
trait TraitAddSecondTraitBoundToTypeParameterOfTraitWhere<T> where T: ReferencedTrait0 { }
@ -908,7 +907,7 @@ trait TraitAddSecondTraitBoundToTypeParameterOfTraitWhere<T>
// Add second lifetime bound to type parameter of trait in where clause------------
// Add second lifetime bound to type parameter of trait in where clause
#[cfg(cfail1)]
trait TraitAddSecondLifetimeBoundToTypeParameterOfTraitWhere<'a, 'b, T> where T: 'a { }
@ -919,7 +918,7 @@ trait TraitAddSecondLifetimeBoundToTypeParameterOfTraitWhere<'a, 'b, T> where T:
// Add second lifetime bound to lifetime parameter of trait in where clause--------
// Add second lifetime bound to lifetime parameter of trait in where clause
#[cfg(cfail1)]
trait TraitAddSecondLifetimeBoundToLifetimeParameterOfTraitWhere<'a, 'b, 'c> where 'a: 'b { }
@ -930,7 +929,7 @@ trait TraitAddSecondLifetimeBoundToLifetimeParameterOfTraitWhere<'a, 'b, 'c> whe
// Add second builtin bound to type parameter of trait in where clause-------------
// Add second builtin bound to type parameter of trait in where clause
#[cfg(cfail1)]
trait TraitAddSecondBuiltinBoundToTypeParameterOfTraitWhere<T> where T: Send { }
@ -940,7 +939,7 @@ trait TraitAddSecondBuiltinBoundToTypeParameterOfTraitWhere<T> where T: Send { }
trait TraitAddSecondBuiltinBoundToTypeParameterOfTraitWhere<T> where T: Send + Sync { }
// Change return type of method indirectly by modifying a use statement------------
// Change return type of method indirectly by modifying a use statement
mod change_return_type_of_method_indirectly_use {
#[cfg(cfail1)]
use super::ReferenceType0 as ReturnType;
@ -958,7 +957,7 @@ mod change_return_type_of_method_indirectly_use {
// Change type of method parameter indirectly by modifying a use statement---------
// Change type of method parameter indirectly by modifying a use statement
mod change_method_parameter_type_indirectly_by_use {
#[cfg(cfail1)]
use super::ReferenceType0 as ArgType;

18
src/test/incremental/hashes/while_let_loops.rs
View file

@ -14,7 +14,7 @@
#![crate_type="rlib"]
// Change loop body ------------------------------------------------------------
// Change loop body
#[cfg(cfail1)]
pub fn change_loop_body() {
let mut _x = 0;
@ -37,7 +37,7 @@ pub fn change_loop_body() {
// Change loop body ------------------------------------------------------------
// Change loop body
#[cfg(cfail1)]
pub fn change_loop_condition() {
let mut _x = 0;
@ -60,7 +60,7 @@ pub fn change_loop_condition() {
// Add break -------------------------------------------------------------------
// Add break
#[cfg(cfail1)]
pub fn add_break() {
let mut _x = 0;
@ -82,7 +82,7 @@ pub fn add_break() {
// Add loop label --------------------------------------------------------------
// Add loop label
#[cfg(cfail1)]
pub fn add_loop_label() {
let mut _x = 0;
@ -105,7 +105,7 @@ pub fn add_loop_label() {
// Add loop label to break -----------------------------------------------------
// Add loop label to break
#[cfg(cfail1)]
pub fn add_loop_label_to_break() {
let mut _x = 0;
@ -128,7 +128,7 @@ pub fn add_loop_label_to_break() {
// Change break label ----------------------------------------------------------
// Change break label
#[cfg(cfail1)]
pub fn change_break_label() {
let mut _x = 0;
@ -155,7 +155,7 @@ pub fn change_break_label() {
// Add loop label to continue --------------------------------------------------
// Add loop label to continue
#[cfg(cfail1)]
pub fn add_loop_label_to_continue() {
let mut _x = 0;
@ -178,7 +178,7 @@ pub fn add_loop_label_to_continue() {
// Change continue label ----------------------------------------------------------
// Change continue label
#[cfg(cfail1)]
pub fn change_continue_label() {
let mut _x = 0;
@ -205,7 +205,7 @@ pub fn change_continue_label() {
// Change continue to break ----------------------------------------------------
// Change continue to break
#[cfg(cfail1)]
pub fn change_continue_to_break() {
let mut _x = 0;

18
src/test/incremental/hashes/while_loops.rs
View file

@ -14,7 +14,7 @@
#![crate_type="rlib"]
// Change loop body ------------------------------------------------------------
// Change loop body
#[cfg(cfail1)]
pub fn change_loop_body() {
let mut _x = 0;
@ -37,7 +37,7 @@ pub fn change_loop_body() {
// Change loop body ------------------------------------------------------------
// Change loop body
#[cfg(cfail1)]
pub fn change_loop_condition() {
let mut _x = 0;
@ -60,7 +60,7 @@ pub fn change_loop_condition() {
// Add break -------------------------------------------------------------------
// Add break
#[cfg(cfail1)]
pub fn add_break() {
let mut _x = 0;
@ -82,7 +82,7 @@ pub fn add_break() {
// Add loop label --------------------------------------------------------------
// Add loop label
#[cfg(cfail1)]
pub fn add_loop_label() {
let mut _x = 0;
@ -105,7 +105,7 @@ pub fn add_loop_label() {
// Add loop label to break -----------------------------------------------------
// Add loop label to break
#[cfg(cfail1)]
pub fn add_loop_label_to_break() {
let mut _x = 0;
@ -128,7 +128,7 @@ pub fn add_loop_label_to_break() {
// Change break label ----------------------------------------------------------
// Change break label
#[cfg(cfail1)]
pub fn change_break_label() {
let mut _x = 0;
@ -155,7 +155,7 @@ pub fn change_break_label() {
// Add loop label to continue --------------------------------------------------
// Add loop label to continue
#[cfg(cfail1)]
pub fn add_loop_label_to_continue() {
let mut _x = 0;
@ -178,7 +178,7 @@ pub fn add_loop_label_to_continue() {
// Change continue label ----------------------------------------------------------
// Change continue label
#[cfg(cfail1)]
pub fn change_continue_label() {
let mut _x = 0;
@ -205,7 +205,7 @@ pub fn change_continue_label() {
// Change continue to break ----------------------------------------------------
// Change continue to break
#[cfg(cfail1)]
pub fn change_continue_to_break() {
let mut _x = 0;

2
src/test/rustdoc/async-fn.rs
View file

@ -1,7 +1,5 @@
// edition:2018
#![feature(async_await)]
// @has async_fn/fn.foo.html '//pre[@class="rust fn"]' 'pub async fn foo() -> Option<Foo>'
pub async fn foo() -> Option<Foo> {
None

6
src/test/rustdoc/async-move-doctest.rs
View file

@ -1,13 +1,11 @@
// compile-flags:--test
// edition:2018
// prior to setting the default edition for the doctest pre-parser, this doctest would fail due to
// a fatal parsing error
// Prior to setting the default edition for the doctest pre-parser,
// this doctest would fail due to a fatal parsing error.
// see https://github.com/rust-lang/rust/issues/59313
//! ```
//! #![feature(async_await)]
//!
//! fn foo() {
//! drop(async move {});
//! }

3
src/test/rustdoc/edition-flag.rs
View file

@ -1,10 +1,7 @@
// compile-flags:--test -Z unstable-options
// edition:2018
#![feature(async_await)]
/// ```rust
/// #![feature(async_await)]
/// fn main() {
/// let _ = async { };
/// }

1
src/test/ui/async-await/argument-patterns.rs
View file

@ -3,7 +3,6 @@
#![allow(unused_variables)]
#![deny(unused_mut)]
#![feature(async_await)]
type A = Vec<u32>;

2
src/test/ui/async-await/async-await.rs
View file

@ -3,8 +3,6 @@
// edition:2018
// aux-build:arc_wake.rs
#![feature(async_await)]
extern crate arc_wake;
use std::pin::Pin;

2
src/test/ui/async-await/async-block-control-flow-static-semantics.rs
View file

@ -6,8 +6,6 @@
// edition:2018
// ignore-tidy-linelength
#![feature(async_await)]
fn main() {}
use core::future::Future;

16
src/test/ui/async-await/async-block-control-flow-static-semantics.stderr
View file

@ -1,17 +1,17 @@
error[E0267]: `break` inside of an async block
--> $DIR/async-block-control-flow-static-semantics.rs:35:9
--> $DIR/async-block-control-flow-static-semantics.rs:33:9
|
LL | break 0u8;
| ^^^^^^^^^ cannot break inside of an async block
error[E0267]: `break` inside of an async block
--> $DIR/async-block-control-flow-static-semantics.rs:42:13
--> $DIR/async-block-control-flow-static-semantics.rs:40:13
|
LL | break 0u8;
| ^^^^^^^^^ cannot break inside of an async block
error[E0308]: mismatched types
--> $DIR/async-block-control-flow-static-semantics.rs:15:43
--> $DIR/async-block-control-flow-static-semantics.rs:13:43
|
LL | fn return_targets_async_block_not_fn() -> u8 {
| --------------------------------- ^^ expected u8, found ()
@ -22,7 +22,7 @@ LL | fn return_targets_async_block_not_fn() -> u8 {
found type `()`
error[E0271]: type mismatch resolving `<impl std::future::Future as std::future::Future>::Output == ()`
--> $DIR/async-block-control-flow-static-semantics.rs:20:39
--> $DIR/async-block-control-flow-static-semantics.rs:18:39
|
LL | let _: &dyn Future<Output = ()> = &block;
| ^^^^^^ expected u8, found ()
@ -32,7 +32,7 @@ LL | let _: &dyn Future<Output = ()> = &block;
= note: required for the cast to the object type `dyn std::future::Future<Output = ()>`
error[E0271]: type mismatch resolving `<impl std::future::Future as std::future::Future>::Output == ()`
--> $DIR/async-block-control-flow-static-semantics.rs:29:39
--> $DIR/async-block-control-flow-static-semantics.rs:27:39
|
LL | let _: &dyn Future<Output = ()> = &block;
| ^^^^^^ expected u8, found ()
@ -42,7 +42,7 @@ LL | let _: &dyn Future<Output = ()> = &block;
= note: required for the cast to the object type `dyn std::future::Future<Output = ()>`
error[E0271]: type mismatch resolving `<impl std::future::Future as std::future::Future>::Output == u8`
--> $DIR/async-block-control-flow-static-semantics.rs:24:55
--> $DIR/async-block-control-flow-static-semantics.rs:22:55
|
LL | async fn return_targets_async_block_not_async_fn() -> u8 {
| ^^ expected (), found u8
@ -52,7 +52,7 @@ LL | async fn return_targets_async_block_not_async_fn() -> u8 {
= note: the return type of a function must have a statically known size
error[E0308]: mismatched types
--> $DIR/async-block-control-flow-static-semantics.rs:50:44
--> $DIR/async-block-control-flow-static-semantics.rs:48:44
|
LL | fn rethrow_targets_async_block_not_fn() -> Result<u8, MyErr> {
| ---------------------------------- ^^^^^^^^^^^^^^^^^ expected enum `std::result::Result`, found ()
@ -63,7 +63,7 @@ LL | fn rethrow_targets_async_block_not_fn() -> Result<u8, MyErr> {
found type `()`
error[E0308]: mismatched types
--> $DIR/async-block-control-flow-static-semantics.rs:59:50
--> $DIR/async-block-control-flow-static-semantics.rs:57:50
|
LL | fn rethrow_targets_async_block_not_async_fn() -> Result<u8, MyErr> {
| ---------------------------------------- ^^^^^^^^^^^^^^^^^ expected enum `std::result::Result`, found ()

2
src/test/ui/async-await/async-closure-matches-expr.rs
View file

@ -1,7 +1,7 @@
// build-pass
// edition:2018
#![feature(async_await, async_closure)]
#![feature(async_closure)]
macro_rules! match_expr {
($x:expr) => {}

2
src/test/ui/async-await/async-closure.rs
View file

@ -3,7 +3,7 @@
// edition:2018
// aux-build:arc_wake.rs
#![feature(async_await, async_closure)]
#![feature(async_closure)]
extern crate arc_wake;

3
src/test/ui/async-await/async-error-span.rs
View file

@ -1,7 +1,6 @@
// edition:2018
#![feature(async_await)]
// Regression test for issue #62382
// Regression test for issue #62382.
use std::future::Future;

4
src/test/ui/async-await/async-error-span.stderr
View file

@ -1,11 +1,11 @@
error[E0698]: type inside `async` object must be known in this context
--> $DIR/async-error-span.rs:13:9
--> $DIR/async-error-span.rs:12:9
|
LL | let a;
| ^ cannot infer type
|
note: the type is part of the `async` object because of this `await`
--> $DIR/async-error-span.rs:14:5
--> $DIR/async-error-span.rs:13:5
|
LL | get_future().await;
| ^^^^^^^^^^^^^^^^^^

2
src/test/ui/async-await/async-fn-elided-impl-lifetime-parameter.rs
View file

@ -6,8 +6,6 @@
// check-pass
// edition:2018
#![feature(async_await)]
struct Foo<'a>(&'a u8);
impl Foo<'_> {

2
src/test/ui/async-await/async-fn-nonsend.rs
View file

@ -2,8 +2,6 @@
// edition:2018
// compile-flags: --crate-type lib
#![feature(async_await)]
use std::{
cell::RefCell,
fmt::Debug,

32
src/test/ui/async-await/async-fn-nonsend.stderr
View file

@ -1,5 +1,5 @@
error[E0277]: `std::rc::Rc<()>` cannot be sent between threads safely
--> $DIR/async-fn-nonsend.rs:52:5
--> $DIR/async-fn-nonsend.rs:50:5
|
LL | assert_send(local_dropped_before_await());
| ^^^^^^^^^^^ `std::rc::Rc<()>` cannot be sent between threads safely
@ -7,18 +7,18 @@ LL | assert_send(local_dropped_before_await());
= help: within `impl std::future::Future`, the trait `std::marker::Send` is not implemented for `std::rc::Rc<()>`
= note: required because it appears within the type `impl std::fmt::Debug`
= note: required because it appears within the type `{impl std::fmt::Debug, impl std::future::Future, ()}`
= note: required because it appears within the type `[static generator@$DIR/async-fn-nonsend.rs:23:39: 28:2 {impl std::fmt::Debug, impl std::future::Future, ()}]`
= note: required because it appears within the type `std::future::GenFuture<[static generator@$DIR/async-fn-nonsend.rs:23:39: 28:2 {impl std::fmt::Debug, impl std::future::Future, ()}]>`
= note: required because it appears within the type `[static generator@$DIR/async-fn-nonsend.rs:21:39: 26:2 {impl std::fmt::Debug, impl std::future::Future, ()}]`
= note: required because it appears within the type `std::future::GenFuture<[static generator@$DIR/async-fn-nonsend.rs:21:39: 26:2 {impl std::fmt::Debug, impl std::future::Future, ()}]>`
= note: required because it appears within the type `impl std::future::Future`
= note: required because it appears within the type `impl std::future::Future`
note: required by `assert_send`
--> $DIR/async-fn-nonsend.rs:49:1
--> $DIR/async-fn-nonsend.rs:47:1
|
LL | fn assert_send(_: impl Send) {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0277]: `std::rc::Rc<()>` cannot be sent between threads safely
--> $DIR/async-fn-nonsend.rs:54:5
--> $DIR/async-fn-nonsend.rs:52:5
|
LL | assert_send(non_send_temporary_in_match());
| ^^^^^^^^^^^ `std::rc::Rc<()>` cannot be sent between threads safely
@ -26,18 +26,18 @@ LL | assert_send(non_send_temporary_in_match());
= help: within `impl std::future::Future`, the trait `std::marker::Send` is not implemented for `std::rc::Rc<()>`
= note: required because it appears within the type `impl std::fmt::Debug`
= note: required because it appears within the type `{fn(impl std::fmt::Debug) -> std::option::Option<impl std::fmt::Debug> {std::option::Option::<impl std::fmt::Debug>::Some}, fn() -> impl std::fmt::Debug {non_send}, impl std::fmt::Debug, std::option::Option<impl std::fmt::Debug>, impl std::future::Future, ()}`
= note: required because it appears within the type `[static generator@$DIR/async-fn-nonsend.rs:30:40: 39:2 {fn(impl std::fmt::Debug) -> std::option::Option<impl std::fmt::Debug> {std::option::Option::<impl std::fmt::Debug>::Some}, fn() -> impl std::fmt::Debug {non_send}, impl std::fmt::Debug, std::option::Option<impl std::fmt::Debug>, impl std::future::Future, ()}]`
= note: required because it appears within the type `std::future::GenFuture<[static generator@$DIR/async-fn-nonsend.rs:30:40: 39:2 {fn(impl std::fmt::Debug) -> std::option::Option<impl std::fmt::Debug> {std::option::Option::<impl std::fmt::Debug>::Some}, fn() -> impl std::fmt::Debug {non_send}, impl std::fmt::Debug, std::option::Option<impl std::fmt::Debug>, impl std::future::Future, ()}]>`
= note: required because it appears within the type `[static generator@$DIR/async-fn-nonsend.rs:28:40: 37:2 {fn(impl std::fmt::Debug) -> std::option::Option<impl std::fmt::Debug> {std::option::Option::<impl std::fmt::Debug>::Some}, fn() -> impl std::fmt::Debug {non_send}, impl std::fmt::Debug, std::option::Option<impl std::fmt::Debug>, impl std::future::Future, ()}]`
= note: required because it appears within the type `std::future::GenFuture<[static generator@$DIR/async-fn-nonsend.rs:28:40: 37:2 {fn(impl std::fmt::Debug) -> std::option::Option<impl std::fmt::Debug> {std::option::Option::<impl std::fmt::Debug>::Some}, fn() -> impl std::fmt::Debug {non_send}, impl std::fmt::Debug, std::option::Option<impl std::fmt::Debug>, impl std::future::Future, ()}]>`
= note: required because it appears within the type `impl std::future::Future`
= note: required because it appears within the type `impl std::future::Future`
note: required by `assert_send`
--> $DIR/async-fn-nonsend.rs:49:1
--> $DIR/async-fn-nonsend.rs:47:1
|
LL | fn assert_send(_: impl Send) {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0277]: `dyn std::fmt::Write` cannot be sent between threads safely
--> $DIR/async-fn-nonsend.rs:56:5
--> $DIR/async-fn-nonsend.rs:54:5
|
LL | assert_send(non_sync_with_method_call());
| ^^^^^^^^^^^ `dyn std::fmt::Write` cannot be sent between threads safely
@ -47,18 +47,18 @@ LL | assert_send(non_sync_with_method_call());
= note: required because it appears within the type `std::fmt::Formatter<'_>`
= note: required because of the requirements on the impl of `std::marker::Send` for `&mut std::fmt::Formatter<'_>`
= note: required because it appears within the type `for<'r, 's> {&'r mut std::fmt::Formatter<'s>, bool, impl std::future::Future, ()}`
= note: required because it appears within the type `[static generator@$DIR/async-fn-nonsend.rs:41:38: 47:2 for<'r, 's> {&'r mut std::fmt::Formatter<'s>, bool, impl std::future::Future, ()}]`
= note: required because it appears within the type `std::future::GenFuture<[static generator@$DIR/async-fn-nonsend.rs:41:38: 47:2 for<'r, 's> {&'r mut std::fmt::Formatter<'s>, bool, impl std::future::Future, ()}]>`
= note: required because it appears within the type `[static generator@$DIR/async-fn-nonsend.rs:39:38: 45:2 for<'r, 's> {&'r mut std::fmt::Formatter<'s>, bool, impl std::future::Future, ()}]`
= note: required because it appears within the type `std::future::GenFuture<[static generator@$DIR/async-fn-nonsend.rs:39:38: 45:2 for<'r, 's> {&'r mut std::fmt::Formatter<'s>, bool, impl std::future::Future, ()}]>`
= note: required because it appears within the type `impl std::future::Future`
= note: required because it appears within the type `impl std::future::Future`
note: required by `assert_send`
--> $DIR/async-fn-nonsend.rs:49:1
--> $DIR/async-fn-nonsend.rs:47:1
|
LL | fn assert_send(_: impl Send) {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0277]: `*mut (dyn std::ops::Fn() + 'static)` cannot be shared between threads safely
--> $DIR/async-fn-nonsend.rs:56:5
--> $DIR/async-fn-nonsend.rs:54:5
|
LL | assert_send(non_sync_with_method_call());
| ^^^^^^^^^^^ `*mut (dyn std::ops::Fn() + 'static)` cannot be shared between threads safely
@ -72,12 +72,12 @@ LL | assert_send(non_sync_with_method_call());
= note: required because it appears within the type `std::fmt::Formatter<'_>`
= note: required because of the requirements on the impl of `std::marker::Send` for `&mut std::fmt::Formatter<'_>`
= note: required because it appears within the type `for<'r, 's> {&'r mut std::fmt::Formatter<'s>, bool, impl std::future::Future, ()}`
= note: required because it appears within the type `[static generator@$DIR/async-fn-nonsend.rs:41:38: 47:2 for<'r, 's> {&'r mut std::fmt::Formatter<'s>, bool, impl std::future::Future, ()}]`
= note: required because it appears within the type `std::future::GenFuture<[static generator@$DIR/async-fn-nonsend.rs:41:38: 47:2 for<'r, 's> {&'r mut std::fmt::Formatter<'s>, bool, impl std::future::Future, ()}]>`
= note: required because it appears within the type `[static generator@$DIR/async-fn-nonsend.rs:39:38: 45:2 for<'r, 's> {&'r mut std::fmt::Formatter<'s>, bool, impl std::future::Future, ()}]`
= note: required because it appears within the type `std::future::GenFuture<[static generator@$DIR/async-fn-nonsend.rs:39:38: 45:2 for<'r, 's> {&'r mut std::fmt::Formatter<'s>, bool, impl std::future::Future, ()}]>`
= note: required because it appears within the type `impl std::future::Future`
= note: required because it appears within the type `impl std::future::Future`
note: required by `assert_send`
--> $DIR/async-fn-nonsend.rs:49:1
--> $DIR/async-fn-nonsend.rs:47:1
|
LL | fn assert_send(_: impl Send) {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

3
src/test/ui/async-await/async-fn-path-elision.rs
View file

@ -1,8 +1,5 @@
// edition:2018
#![feature(async_await)]
#![allow(dead_code)]
struct HasLifetime<'a>(&'a bool);
async fn error(lt: HasLifetime) { //~ ERROR implicit elided lifetime not allowed here

2
src/test/ui/async-await/async-fn-path-elision.stderr
View file

@ -1,5 +1,5 @@
error[E0726]: implicit elided lifetime not allowed here
--> $DIR/async-fn-path-elision.rs:8:20
--> $DIR/async-fn-path-elision.rs:5:20
|
LL | async fn error(lt: HasLifetime) {
| ^^^^^^^^^^^- help: indicate the anonymous lifetime: `<'_>`

2
src/test/ui/async-await/async-fn-send-uses-nonsend.rs
View file

@ -2,8 +2,6 @@
// edition:2018
// compile-flags: --crate-type lib
#![feature(async_await)]
use std::{
cell::RefCell,
fmt::Debug,

2
src/test/ui/async-await/async-fn-size-moved-locals.rs
View file

@ -12,8 +12,6 @@
// edition:2018
#![feature(async_await)]
use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};

2
src/test/ui/async-await/async-fn-size.rs
View file

@ -2,8 +2,6 @@
// aux-build:arc_wake.rs
// edition:2018
#![feature(async_await)]
extern crate arc_wake;
use std::pin::Pin;

2
src/test/ui/async-await/async-matches-expr.rs
View file

@ -1,8 +1,6 @@
// build-pass (FIXME(62277): could be check-pass?)
// edition:2018
#![feature(async_await)]
macro_rules! match_expr {
($x:expr) => {}
}

2
src/test/ui/async-await/async-unsafe-fn-call-in-safe.rs
View file

@ -1,7 +1,5 @@
// edition:2018
#![feature(async_await)]
struct S;
impl S {

8
src/test/ui/async-await/async-unsafe-fn-call-in-safe.stderr
View file

@ -1,5 +1,5 @@
error[E0133]: call to unsafe function is unsafe and requires unsafe function or block
--> $DIR/async-unsafe-fn-call-in-safe.rs:14:5
--> $DIR/async-unsafe-fn-call-in-safe.rs:12:5
|
LL | S::f();
| ^^^^^^ call to unsafe function
@ -7,7 +7,7 @@ LL | S::f();
= note: consult the function's documentation for information on how to avoid undefined behavior
error[E0133]: call to unsafe function is unsafe and requires unsafe function or block
--> $DIR/async-unsafe-fn-call-in-safe.rs:15:5
--> $DIR/async-unsafe-fn-call-in-safe.rs:13:5
|
LL | f();
| ^^^ call to unsafe function
@ -15,7 +15,7 @@ LL | f();
= note: consult the function's documentation for information on how to avoid undefined behavior
error[E0133]: call to unsafe function is unsafe and requires unsafe function or block
--> $DIR/async-unsafe-fn-call-in-safe.rs:19:5
--> $DIR/async-unsafe-fn-call-in-safe.rs:17:5
|
LL | S::f();
| ^^^^^^ call to unsafe function
@ -23,7 +23,7 @@ LL | S::f();
= note: consult the function's documentation for information on how to avoid undefined behavior
error[E0133]: call to unsafe function is unsafe and requires unsafe function or block
--> $DIR/async-unsafe-fn-call-in-safe.rs:20:5
--> $DIR/async-unsafe-fn-call-in-safe.rs:18:5
|
LL | f();
| ^^^ call to unsafe function

2
src/test/ui/async-await/async-with-closure.rs
View file

@ -1,8 +1,6 @@
// build-pass (FIXME(62277): could be check-pass?)
// edition:2018
#![feature(async_await)]
trait MyClosure {
type Args;
}

1
src/test/ui/async-await/await-keyword/2015-edition-error-various-positions.rs
View file

@ -1,4 +1,3 @@
#![feature(async_await)]
#![allow(non_camel_case_types)]
#![deny(keyword_idents)]

22
src/test/ui/async-await/await-keyword/2015-edition-error-various-positions.stderr
View file

@ -1,11 +1,11 @@
error: `await` is a keyword in the 2018 edition
--> $DIR/2015-edition-error-various-positions.rs:6:13
--> $DIR/2015-edition-error-various-positions.rs:5:13
|
LL | pub mod await {
| ^^^^^ help: you can use a raw identifier to stay compatible: `r#await`
|
note: lint level defined here
--> $DIR/2015-edition-error-various-positions.rs:3:9
--> $DIR/2015-edition-error-various-positions.rs:2:9
|
LL | #![deny(keyword_idents)]
| ^^^^^^^^^^^^^^
@ -13,7 +13,7 @@ LL | #![deny(keyword_idents)]
= note: for more information, see issue #49716 <https://github.com/rust-lang/rust/issues/49716>
error: `await` is a keyword in the 2018 edition
--> $DIR/2015-edition-error-various-positions.rs:8:20
--> $DIR/2015-edition-error-various-positions.rs:7:20
|
LL | pub struct await;
| ^^^^^ help: you can use a raw identifier to stay compatible: `r#await`
@ -22,7 +22,7 @@ LL | pub struct await;
= note: for more information, see issue #49716 <https://github.com/rust-lang/rust/issues/49716>
error: `await` is a keyword in the 2018 edition
--> $DIR/2015-edition-error-various-positions.rs:12:16
--> $DIR/2015-edition-error-various-positions.rs:11:16
|
LL | use outer_mod::await::await;
| ^^^^^ help: you can use a raw identifier to stay compatible: `r#await`
@ -31,7 +31,7 @@ LL | use outer_mod::await::await;
= note: for more information, see issue #49716 <https://github.com/rust-lang/rust/issues/49716>
error: `await` is a keyword in the 2018 edition
--> $DIR/2015-edition-error-various-positions.rs:12:23
--> $DIR/2015-edition-error-various-positions.rs:11:23
|
LL | use outer_mod::await::await;
| ^^^^^ help: you can use a raw identifier to stay compatible: `r#await`
@ -40,7 +40,7 @@ LL | use outer_mod::await::await;
= note: for more information, see issue #49716 <https://github.com/rust-lang/rust/issues/49716>
error: `await` is a keyword in the 2018 edition
--> $DIR/2015-edition-error-various-positions.rs:17:14
--> $DIR/2015-edition-error-various-positions.rs:16:14
|
LL | struct Foo { await: () }
| ^^^^^ help: you can use a raw identifier to stay compatible: `r#await`
@ -49,7 +49,7 @@ LL | struct Foo { await: () }
= note: for more information, see issue #49716 <https://github.com/rust-lang/rust/issues/49716>
error: `await` is a keyword in the 2018 edition
--> $DIR/2015-edition-error-various-positions.rs:21:15
--> $DIR/2015-edition-error-various-positions.rs:20:15
|
LL | impl Foo { fn await() {} }
| ^^^^^ help: you can use a raw identifier to stay compatible: `r#await`
@ -58,7 +58,7 @@ LL | impl Foo { fn await() {} }
= note: for more information, see issue #49716 <https://github.com/rust-lang/rust/issues/49716>
error: `await` is a keyword in the 2018 edition
--> $DIR/2015-edition-error-various-positions.rs:25:14
--> $DIR/2015-edition-error-various-positions.rs:24:14
|
LL | macro_rules! await {
| ^^^^^ help: you can use a raw identifier to stay compatible: `r#await`
@ -67,7 +67,7 @@ LL | macro_rules! await {
= note: for more information, see issue #49716 <https://github.com/rust-lang/rust/issues/49716>
error: `await` is a keyword in the 2018 edition
--> $DIR/2015-edition-error-various-positions.rs:32:5
--> $DIR/2015-edition-error-various-positions.rs:31:5
|
LL | await!();
| ^^^^^ help: you can use a raw identifier to stay compatible: `r#await`
@ -76,7 +76,7 @@ LL | await!();
= note: for more information, see issue #49716 <https://github.com/rust-lang/rust/issues/49716>
error: `await` is a keyword in the 2018 edition
--> $DIR/2015-edition-error-various-positions.rs:35:11
--> $DIR/2015-edition-error-various-positions.rs:34:11
|
LL | match await { await => {} }
| ^^^^^ help: you can use a raw identifier to stay compatible: `r#await`
@ -85,7 +85,7 @@ LL | match await { await => {} }
= note: for more information, see issue #49716 <https://github.com/rust-lang/rust/issues/49716>
error: `await` is a keyword in the 2018 edition
--> $DIR/2015-edition-error-various-positions.rs:35:19
--> $DIR/2015-edition-error-various-positions.rs:34:19
|
LL | match await { await => {} }
| ^^^^^ help: you can use a raw identifier to stay compatible: `r#await`

1
src/test/ui/async-await/await-keyword/2018-edition-error-in-non-macro-position.rs
View file

@ -1,7 +1,6 @@
// edition:2018
#![allow(non_camel_case_types)]
#![feature(async_await)]
mod outer_mod {
pub mod await { //~ ERROR expected identifier, found reserved keyword `await`

14
src/test/ui/async-await/await-keyword/2018-edition-error-in-non-macro-position.stderr
View file

@ -1,5 +1,5 @@
error: expected identifier, found reserved keyword `await`
--> $DIR/2018-edition-error-in-non-macro-position.rs:7:13
--> $DIR/2018-edition-error-in-non-macro-position.rs:6:13
|
LL | pub mod await {
| ^^^^^ expected identifier, found reserved keyword
@ -9,7 +9,7 @@ LL | pub mod r#await {
| ^^^^^^^
error: expected identifier, found reserved keyword `await`
--> $DIR/2018-edition-error-in-non-macro-position.rs:8:20
--> $DIR/2018-edition-error-in-non-macro-position.rs:7:20
|
LL | pub struct await;
| ^^^^^ expected identifier, found reserved keyword
@ -19,7 +19,7 @@ LL | pub struct r#await;
| ^^^^^^^
error: expected identifier, found reserved keyword `await`
--> $DIR/2018-edition-error-in-non-macro-position.rs:11:22
--> $DIR/2018-edition-error-in-non-macro-position.rs:10:22
|
LL | use self::outer_mod::await::await;
| ^^^^^ expected identifier, found reserved keyword
@ -29,7 +29,7 @@ LL | use self::outer_mod::r#await::await;
| ^^^^^^^
error: expected identifier, found reserved keyword `await`
--> $DIR/2018-edition-error-in-non-macro-position.rs:11:29
--> $DIR/2018-edition-error-in-non-macro-position.rs:10:29
|
LL | use self::outer_mod::await::await;
| ^^^^^ expected identifier, found reserved keyword
@ -39,7 +39,7 @@ LL | use self::outer_mod::await::r#await;
| ^^^^^^^
error: expected identifier, found reserved keyword `await`
--> $DIR/2018-edition-error-in-non-macro-position.rs:14:14
--> $DIR/2018-edition-error-in-non-macro-position.rs:13:14
|
LL | struct Foo { await: () }
| ^^^^^ expected identifier, found reserved keyword
@ -49,7 +49,7 @@ LL | struct Foo { r#await: () }
| ^^^^^^^
error: expected identifier, found reserved keyword `await`
--> $DIR/2018-edition-error-in-non-macro-position.rs:17:15
--> $DIR/2018-edition-error-in-non-macro-position.rs:16:15
|
LL | impl Foo { fn await() {} }
| ^^^^^ expected identifier, found reserved keyword
@ -59,7 +59,7 @@ LL | impl Foo { fn r#await() {} }
| ^^^^^^^
error: expected identifier, found reserved keyword `await`
--> $DIR/2018-edition-error-in-non-macro-position.rs:20:14
--> $DIR/2018-edition-error-in-non-macro-position.rs:19:14
|
LL | macro_rules! await {
| ^^^^^ expected identifier, found reserved keyword

2
src/test/ui/async-await/await-keyword/incorrect-syntax-suggestions.rs
View file

@ -1,7 +1,5 @@
// edition:2018
#![feature(async_await)]
async fn bar() -> Result<(), ()> {
Ok(())
}

70
src/test/ui/async-await/await-keyword/incorrect-syntax-suggestions.stderr
View file

@ -1,119 +1,119 @@
error: incorrect use of `await`
--> $DIR/incorrect-syntax-suggestions.rs:10:13
--> $DIR/incorrect-syntax-suggestions.rs:8:13
|
LL | let _ = await bar();
| ^^^^^^^^^^^ help: `await` is a postfix operation: `bar().await`
error: incorrect use of `await`
--> $DIR/incorrect-syntax-suggestions.rs:14:13
--> $DIR/incorrect-syntax-suggestions.rs:12:13
|
LL | let _ = await? bar();
| ^^^^^^^^^^^^ help: `await` is a postfix operation: `bar().await?`
error: incorrect use of `await`
--> $DIR/incorrect-syntax-suggestions.rs:18:13
--> $DIR/incorrect-syntax-suggestions.rs:16:13
|
LL | let _ = await bar()?;
| ^^^^^^^^^^^^ help: `await` is a postfix operation: `bar()?.await`
error: incorrect use of `await`
--> $DIR/incorrect-syntax-suggestions.rs:23:13
--> $DIR/incorrect-syntax-suggestions.rs:21:13
|
LL | let _ = await { bar() };
| ^^^^^^^^^^^^^^^ help: `await` is a postfix operation: `{ bar() }.await`
error: incorrect use of `await`
--> $DIR/incorrect-syntax-suggestions.rs:27:13
--> $DIR/incorrect-syntax-suggestions.rs:25:13
|
LL | let _ = await(bar());
| ^^^^^^^^^^^^ help: `await` is a postfix operation: `(bar()).await`
error: incorrect use of `await`
--> $DIR/incorrect-syntax-suggestions.rs:31:13
--> $DIR/incorrect-syntax-suggestions.rs:29:13
|
LL | let _ = await { bar() }?;
| ^^^^^^^^^^^^^^^ help: `await` is a postfix operation: `{ bar() }.await`
error: incorrect use of `await`
--> $DIR/incorrect-syntax-suggestions.rs:35:14
--> $DIR/incorrect-syntax-suggestions.rs:33:14
|
LL | let _ = (await bar())?;
| ^^^^^^^^^^^ help: `await` is a postfix operation: `bar().await`
error: incorrect use of `await`
--> $DIR/incorrect-syntax-suggestions.rs:39:24
--> $DIR/incorrect-syntax-suggestions.rs:37:24
|
LL | let _ = bar().await();
| ^^ help: `await` is not a method call, remove the parentheses
error: incorrect use of `await`
--> $DIR/incorrect-syntax-suggestions.rs:43:24
--> $DIR/incorrect-syntax-suggestions.rs:41:24
|
LL | let _ = bar().await()?;
| ^^ help: `await` is not a method call, remove the parentheses
error: incorrect use of `await`
--> $DIR/incorrect-syntax-suggestions.rs:55:13
--> $DIR/incorrect-syntax-suggestions.rs:53:13
|
LL | let _ = await bar();
| ^^^^^^^^^^^ help: `await` is a postfix operation: `bar().await`
error: incorrect use of `await`
--> $DIR/incorrect-syntax-suggestions.rs:60:13
--> $DIR/incorrect-syntax-suggestions.rs:58:13
|
LL | let _ = await? bar();
| ^^^^^^^^^^^^ help: `await` is a postfix operation: `bar().await?`
error: incorrect use of `await`
--> $DIR/incorrect-syntax-suggestions.rs:65:13
--> $DIR/incorrect-syntax-suggestions.rs:63:13
|
LL | let _ = await bar()?;
| ^^^^^^^^^^^^ help: `await` is a postfix operation: `bar()?.await`
error: incorrect use of `await`
--> $DIR/incorrect-syntax-suggestions.rs:70:14
--> $DIR/incorrect-syntax-suggestions.rs:68:14
|
LL | let _ = (await bar())?;
| ^^^^^^^^^^^ help: `await` is a postfix operation: `bar().await`
error: incorrect use of `await`
--> $DIR/incorrect-syntax-suggestions.rs:75:24
--> $DIR/incorrect-syntax-suggestions.rs:73:24
|
LL | let _ = bar().await();
| ^^ help: `await` is not a method call, remove the parentheses
error: incorrect use of `await`
--> $DIR/incorrect-syntax-suggestions.rs:80:24
--> $DIR/incorrect-syntax-suggestions.rs:78:24
|
LL | let _ = bar().await()?;
| ^^ help: `await` is not a method call, remove the parentheses
error: incorrect use of `await`
--> $DIR/incorrect-syntax-suggestions.rs:108:13
--> $DIR/incorrect-syntax-suggestions.rs:106:13
|
LL | let _ = await!(bar());
| ^^^^^^^^^^^^^ help: `await` is a postfix operation: `bar().await`
error: incorrect use of `await`
--> $DIR/incorrect-syntax-suggestions.rs:112:13
--> $DIR/incorrect-syntax-suggestions.rs:110:13
|
LL | let _ = await!(bar())?;
| ^^^^^^^^^^^^^ help: `await` is a postfix operation: `bar().await`
error: incorrect use of `await`
--> $DIR/incorrect-syntax-suggestions.rs:117:17
--> $DIR/incorrect-syntax-suggestions.rs:115:17
|
LL | let _ = await!(bar())?;
| ^^^^^^^^^^^^^ help: `await` is a postfix operation: `bar().await`
error: incorrect use of `await`
--> $DIR/incorrect-syntax-suggestions.rs:125:17
--> $DIR/incorrect-syntax-suggestions.rs:123:17
|
LL | let _ = await!(bar())?;
| ^^^^^^^^^^^^^ help: `await` is a postfix operation: `bar().await`
error: expected expression, found `=>`
--> $DIR/incorrect-syntax-suggestions.rs:133:25
--> $DIR/incorrect-syntax-suggestions.rs:131:25
|
LL | match await { await => () }
| ----- ^^ expected expression
@ -121,13 +121,13 @@ LL | match await { await => () }
| while parsing this incorrect await expression
error: incorrect use of `await`
--> $DIR/incorrect-syntax-suggestions.rs:133:11
--> $DIR/incorrect-syntax-suggestions.rs:131:11
|
LL | match await { await => () }
| ^^^^^^^^^^^^^^^^^^^^^ help: `await` is a postfix operation: `{ await => () }.await`
error: expected one of `.`, `?`, `{`, or an operator, found `}`
--> $DIR/incorrect-syntax-suggestions.rs:136:1
--> $DIR/incorrect-syntax-suggestions.rs:134:1
|
LL | match await { await => () }
| ----- - expected one of `.`, `?`, `{`, or an operator here
@ -138,7 +138,7 @@ LL | }
| ^ unexpected token
error[E0728]: `await` is only allowed inside `async` functions and blocks
--> $DIR/incorrect-syntax-suggestions.rs:55:13
--> $DIR/incorrect-syntax-suggestions.rs:53:13
|
LL | fn foo9() -> Result<(), ()> {
| ---- this is not `async`
@ -146,7 +146,7 @@ LL | let _ = await bar();
| ^^^^^^^^^^^ only allowed inside `async` functions and blocks
error[E0728]: `await` is only allowed inside `async` functions and blocks
--> $DIR/incorrect-syntax-suggestions.rs:60:13
--> $DIR/incorrect-syntax-suggestions.rs:58:13
|
LL | fn foo10() -> Result<(), ()> {
| ----- this is not `async`
@ -154,7 +154,7 @@ LL | let _ = await? bar();
| ^^^^^^^^^^^^ only allowed inside `async` functions and blocks
error[E0728]: `await` is only allowed inside `async` functions and blocks
--> $DIR/incorrect-syntax-suggestions.rs:65:13
--> $DIR/incorrect-syntax-suggestions.rs:63:13
|
LL | fn foo11() -> Result<(), ()> {
| ----- this is not `async`
@ -162,7 +162,7 @@ LL | let _ = await bar()?;
| ^^^^^^^^^^^^ only allowed inside `async` functions and blocks
error[E0728]: `await` is only allowed inside `async` functions and blocks
--> $DIR/incorrect-syntax-suggestions.rs:70:14
--> $DIR/incorrect-syntax-suggestions.rs:68:14
|
LL | fn foo12() -> Result<(), ()> {
| ----- this is not `async`
@ -170,7 +170,7 @@ LL | let _ = (await bar())?;
| ^^^^^^^^^^^ only allowed inside `async` functions and blocks
error[E0728]: `await` is only allowed inside `async` functions and blocks
--> $DIR/incorrect-syntax-suggestions.rs:75:13
--> $DIR/incorrect-syntax-suggestions.rs:73:13
|
LL | fn foo13() -> Result<(), ()> {
| ----- this is not `async`
@ -178,7 +178,7 @@ LL | let _ = bar().await();
| ^^^^^^^^^^^ only allowed inside `async` functions and blocks
error[E0728]: `await` is only allowed inside `async` functions and blocks
--> $DIR/incorrect-syntax-suggestions.rs:80:13
--> $DIR/incorrect-syntax-suggestions.rs:78:13
|
LL | fn foo14() -> Result<(), ()> {
| ----- this is not `async`
@ -186,7 +186,7 @@ LL | let _ = bar().await()?;
| ^^^^^^^^^^^ only allowed inside `async` functions and blocks
error[E0728]: `await` is only allowed inside `async` functions and blocks
--> $DIR/incorrect-syntax-suggestions.rs:85:13
--> $DIR/incorrect-syntax-suggestions.rs:83:13
|
LL | fn foo15() -> Result<(), ()> {
| ----- this is not `async`
@ -194,7 +194,7 @@ LL | let _ = bar().await;
| ^^^^^^^^^^^ only allowed inside `async` functions and blocks
error[E0728]: `await` is only allowed inside `async` functions and blocks
--> $DIR/incorrect-syntax-suggestions.rs:89:13
--> $DIR/incorrect-syntax-suggestions.rs:87:13
|
LL | fn foo16() -> Result<(), ()> {
| ----- this is not `async`
@ -202,7 +202,7 @@ LL | let _ = bar().await?;
| ^^^^^^^^^^^ only allowed inside `async` functions and blocks
error[E0728]: `await` is only allowed inside `async` functions and blocks
--> $DIR/incorrect-syntax-suggestions.rs:94:17
--> $DIR/incorrect-syntax-suggestions.rs:92:17
|
LL | fn foo() -> Result<(), ()> {
| --- this is not `async`
@ -210,7 +210,7 @@ LL | let _ = bar().await?;
| ^^^^^^^^^^^ only allowed inside `async` functions and blocks
error[E0728]: `await` is only allowed inside `async` functions and blocks
--> $DIR/incorrect-syntax-suggestions.rs:101:17
--> $DIR/incorrect-syntax-suggestions.rs:99:17
|
LL | let foo = || {
| -- this is not `async`
@ -218,7 +218,7 @@ LL | let _ = bar().await?;
| ^^^^^^^^^^^ only allowed inside `async` functions and blocks
error[E0728]: `await` is only allowed inside `async` functions and blocks
--> $DIR/incorrect-syntax-suggestions.rs:117:17
--> $DIR/incorrect-syntax-suggestions.rs:115:17
|
LL | fn foo() -> Result<(), ()> {
| --- this is not `async`
@ -226,7 +226,7 @@ LL | let _ = await!(bar())?;
| ^^^^^^^^^^^^^ only allowed inside `async` functions and blocks
error[E0728]: `await` is only allowed inside `async` functions and blocks
--> $DIR/incorrect-syntax-suggestions.rs:125:17
--> $DIR/incorrect-syntax-suggestions.rs:123:17
|
LL | let foo = || {
| -- this is not `async`
@ -234,7 +234,7 @@ LL | let _ = await!(bar())?;
| ^^^^^^^^^^^^^ only allowed inside `async` functions and blocks
error[E0277]: the `?` operator can only be applied to values that implement `std::ops::Try`
--> $DIR/incorrect-syntax-suggestions.rs:18:19
--> $DIR/incorrect-syntax-suggestions.rs:16:19
|
LL | let _ = await bar()?;
| ^^^^^^ the `?` operator cannot be applied to type `impl std::future::Future`

2
src/test/ui/async-await/await-unsize.rs
View file

@ -3,8 +3,6 @@
// check-pass
// edition:2018
#![feature(async_await)]
async fn make_boxed_object() -> Box<dyn Send> {
Box::new(()) as _
}

2
src/test/ui/async-await/bound-normalization.rs
View file

@ -1,8 +1,6 @@
// check-pass
// edition:2018
#![feature(async_await)]
// See issue 60414
trait Trait {

2
src/test/ui/async-await/conditional-and-guaranteed-initialization.rs
View file

@ -2,8 +2,6 @@
// edition:2018
// compile-flags: --crate-type lib
#![feature(async_await)]
async fn conditional_and_guaranteed_initialization(x: usize) -> usize {
let y;
if x > 5 {

1
src/test/ui/async-await/dont-print-desugared-async.rs
View file

@ -1,7 +1,6 @@
// Test that we don't show variables with from async fn desugaring
// edition:2018
#![feature(async_await)]
async fn async_fn(&ref mut s: &[i32]) {}
//~^ ERROR cannot borrow data in a `&` reference as mutable [E0596]

2
src/test/ui/async-await/dont-print-desugared-async.stderr
View file

@ -1,5 +1,5 @@
error[E0596]: cannot borrow data in a `&` reference as mutable
--> $DIR/dont-print-desugared-async.rs:6:20
--> $DIR/dont-print-desugared-async.rs:5:20
|
LL | async fn async_fn(&ref mut s: &[i32]) {}
| -^^^^^^^^^

2
src/test/ui/async-await/dont-suggest-missing-await.rs
View file

@ -2,8 +2,6 @@
// This test ensures we don't make the suggestion in bodies that aren't `async`.
#![feature(async_await)]
fn take_u32(x: u32) {}
async fn make_u32() -> u32 {

2
src/test/ui/async-await/dont-suggest-missing-await.stderr
View file

@ -1,5 +1,5 @@
error[E0308]: mismatched types
--> $DIR/dont-suggest-missing-await.rs:16:18
--> $DIR/dont-suggest-missing-await.rs:14:18
|
LL | take_u32(x)
| ^ expected u32, found opaque type

1
src/test/ui/async-await/drop-order/drop-order-for-async-fn-parameters-by-ref-binding.rs
View file

@ -3,7 +3,6 @@
// run-pass
#![allow(unused_variables)]
#![feature(async_await)]
// Test that the drop order for parameters in a fn and async fn matches up. Also test that
// parameters (used or unused) are not dropped until the async fn completes execution.

1
src/test/ui/async-await/drop-order/drop-order-for-async-fn-parameters.rs
View file

@ -3,7 +3,6 @@
// run-pass
#![allow(unused_variables)]
#![feature(async_await)]
// Test that the drop order for parameters in a fn and async fn matches up. Also test that
// parameters (used or unused) are not dropped until the async fn completes execution.

2
src/test/ui/async-await/drop-order/drop-order-for-locals-when-cancelled.rs
View file

@ -2,9 +2,7 @@
// edition:2018
// run-pass
#![allow(unused_variables)]
#![deny(dead_code)]
#![feature(async_await)]
// Test that the drop order for locals in a fn and async fn matches up.
extern crate arc_wake;

3
src/test/ui/async-await/drop-order/drop-order-locals-are-hidden.rs
View file

@ -1,8 +1,5 @@
// edition:2018
#![allow(unused_variables)]
#![feature(async_await)]
async fn foobar_async(x: u32, (a, _, _c): (u32, u32, u32), _: u32, _y: u32) {
assert_eq!(__arg1, (1, 2, 3)); //~ ERROR cannot find value `__arg1` in this scope [E0425]
assert_eq!(__arg2, 4); //~ ERROR cannot find value `__arg2` in this scope [E0425]

8
src/test/ui/async-await/drop-order/drop-order-locals-are-hidden.stderr
View file

@ -1,23 +1,23 @@
error[E0425]: cannot find value `__arg1` in this scope
--> $DIR/drop-order-locals-are-hidden.rs:7:16
--> $DIR/drop-order-locals-are-hidden.rs:4:16
|
LL | assert_eq!(__arg1, (1, 2, 3));
| ^^^^^^ not found in this scope
error[E0425]: cannot find value `__arg2` in this scope
--> $DIR/drop-order-locals-are-hidden.rs:8:16
--> $DIR/drop-order-locals-are-hidden.rs:5:16
|
LL | assert_eq!(__arg2, 4);
| ^^^^^^ not found in this scope
error[E0425]: cannot find value `__arg0` in this scope
--> $DIR/drop-order-locals-are-hidden.rs:12:16
--> $DIR/drop-order-locals-are-hidden.rs:9:16
|
LL | assert_eq!(__arg0, 1);
| ^^^^^^ not found in this scope
error[E0425]: cannot find value `__arg1` in this scope
--> $DIR/drop-order-locals-are-hidden.rs:13:16
--> $DIR/drop-order-locals-are-hidden.rs:10:16
|
LL | assert_eq!(__arg1, 2);
| ^^^^^^ not found in this scope

3
src/test/ui/async-await/drop-order/drop-order-when-cancelled.rs
View file

@ -2,9 +2,6 @@
// edition:2018
// run-pass
#![allow(unused_variables)]
#![feature(async_await)]
// Test that the drop order for parameters in a fn and async fn matches up. Also test that
// parameters (used or unused) are not dropped until the async fn is cancelled.
// This file is mostly copy-pasted from drop-order-for-async-fn-parameters.rs

2
src/test/ui/async-await/edition-deny-async-fns-2015.rs
View file

@ -1,7 +1,5 @@
// edition:2015
#![feature(async_await)]
async fn foo() {} //~ ERROR `async fn` is not permitted in the 2015 edition
fn baz() { async fn foo() {} } //~ ERROR `async fn` is not permitted in the 2015 edition

20
src/test/ui/async-await/edition-deny-async-fns-2015.stderr
View file

@ -1,59 +1,59 @@
error[E0670]: `async fn` is not permitted in the 2015 edition
--> $DIR/edition-deny-async-fns-2015.rs:5:1
--> $DIR/edition-deny-async-fns-2015.rs:3:1
|
LL | async fn foo() {}
| ^^^^^
error[E0670]: `async fn` is not permitted in the 2015 edition
--> $DIR/edition-deny-async-fns-2015.rs:7:12
--> $DIR/edition-deny-async-fns-2015.rs:5:12
|
LL | fn baz() { async fn foo() {} }
| ^^^^^
error[E0670]: `async fn` is not permitted in the 2015 edition
--> $DIR/edition-deny-async-fns-2015.rs:10:5
--> $DIR/edition-deny-async-fns-2015.rs:8:5
|
LL | async fn bar() {}
| ^^^^^
error[E0670]: `async fn` is not permitted in the 2015 edition
--> $DIR/edition-deny-async-fns-2015.rs:9:1
--> $DIR/edition-deny-async-fns-2015.rs:7:1
|
LL | async fn async_baz() {
| ^^^^^
error[E0670]: `async fn` is not permitted in the 2015 edition
--> $DIR/edition-deny-async-fns-2015.rs:16:5
--> $DIR/edition-deny-async-fns-2015.rs:14:5
|
LL | async fn foo() {}
| ^^^^^
error[E0670]: `async fn` is not permitted in the 2015 edition
--> $DIR/edition-deny-async-fns-2015.rs:20:5
--> $DIR/edition-deny-async-fns-2015.rs:18:5
|
LL | async fn foo() {}
| ^^^^^
error[E0670]: `async fn` is not permitted in the 2015 edition
--> $DIR/edition-deny-async-fns-2015.rs:38:9
--> $DIR/edition-deny-async-fns-2015.rs:36:9
|
LL | async fn bar() {}
| ^^^^^
error[E0670]: `async fn` is not permitted in the 2015 edition
--> $DIR/edition-deny-async-fns-2015.rs:28:9
--> $DIR/edition-deny-async-fns-2015.rs:26:9
|
LL | async fn foo() {}
| ^^^^^
error[E0670]: `async fn` is not permitted in the 2015 edition
--> $DIR/edition-deny-async-fns-2015.rs:33:13
--> $DIR/edition-deny-async-fns-2015.rs:31:13
|
LL | async fn bar() {}
| ^^^^^
error[E0706]: trait fns cannot be declared `async`
--> $DIR/edition-deny-async-fns-2015.rs:20:5
--> $DIR/edition-deny-async-fns-2015.rs:18:5
|
LL | async fn foo() {}
| ^^^^^^^^^^^^^^^^^

2
src/test/ui/async-await/generics-and-bounds.rs
View file

@ -2,8 +2,6 @@
// edition:2018
// compile-flags: --crate-type lib
#![feature(async_await)]
use std::future::Future;
pub async fn simple_generic<T>() {}

3
src/test/ui/async-await/issue-60709.rs
View file

@ -4,9 +4,6 @@
// run-pass
#![feature(async_await)]
#![allow(unused)]
use std::future::Future;
use std::task::Poll;
use std::task::Context;

1
src/test/ui/async-await/issue-61452.rs
View file

@ -1,5 +1,4 @@
// edition:2018
#![feature(async_await)]
pub async fn f(x: Option<usize>) {
x.take();

4
src/test/ui/async-await/issue-61452.stderr
View file

@ -1,5 +1,5 @@
error[E0596]: cannot borrow `x` as mutable, as it is not declared as mutable
--> $DIR/issue-61452.rs:5:5
--> $DIR/issue-61452.rs:4:5
|
LL | pub async fn f(x: Option<usize>) {
| - help: consider changing this to be mutable: `mut x`
@ -7,7 +7,7 @@ LL | x.take();
| ^ cannot borrow as mutable
error[E0384]: cannot assign twice to immutable variable `x`
--> $DIR/issue-61452.rs:10:5
--> $DIR/issue-61452.rs:9:5
|
LL | pub async fn g(x: usize) {
| -

3
src/test/ui/async-await/issue-61793.rs
View file

@ -6,9 +6,6 @@
// build-pass (FIXME(62277): could be check-pass?)
// edition:2018
#![feature(async_await)]
#![allow(unused)]
async fn foo<F>(_: &(), _: F) {}
fn main() {

1
src/test/ui/async-await/issue-61949-self-return-type.rs
View file

@ -1,6 +1,5 @@
// ignore-tidy-linelength
// edition:2018
#![feature(async_await)]
// This test checks that `Self` is prohibited as a return type. See #61949 for context.

2
src/test/ui/async-await/issue-61949-self-return-type.stderr
View file

@ -1,5 +1,5 @@
error: `async fn` return type cannot contain a projection or `Self` that references lifetimes from a parent scope
--> $DIR/issue-61949-self-return-type.rs:12:40
--> $DIR/issue-61949-self-return-type.rs:11:40
|
LL | pub async fn new(_bar: &'a i32) -> Self {
| ^^^^

2
src/test/ui/async-await/issue-62658.rs
View file

@ -4,8 +4,6 @@
// build-pass
// edition:2018
#![feature(async_await)]
async fn noop() {}
async fn foo() {

2
src/test/ui/async-await/issues/issue-51719.rs
View file

@ -2,8 +2,6 @@
//
// Tests that the .await syntax can't be used to make a generator
#![feature(async_await)]
async fn foo() {}
fn make_generator() {

2
src/test/ui/async-await/issues/issue-51719.stderr
View file

@ -1,5 +1,5 @@
error[E0728]: `await` is only allowed inside `async` functions and blocks
--> $DIR/issue-51719.rs:10:19
--> $DIR/issue-51719.rs:8:19
|
LL | let _gen = || foo().await;
| -- ^^^^^^^^^^^ only allowed inside `async` functions and blocks

2
src/test/ui/async-await/issues/issue-51751.rs
View file

@ -1,7 +1,5 @@
// edition:2018
#![feature(async_await)]
async fn inc(limit: i64) -> i64 {
limit + 1
}

2
src/test/ui/async-await/issues/issue-51751.stderr
View file

@ -1,5 +1,5 @@
error[E0728]: `await` is only allowed inside `async` functions and blocks
--> $DIR/issue-51751.rs:11:20
--> $DIR/issue-51751.rs:9:20
|
LL | fn main() {
| ---- this is not `async`

2
src/test/ui/async-await/issues/issue-53249.rs
View file

@ -1,7 +1,7 @@
// build-pass (FIXME(62277): could be check-pass?)
// edition:2018
#![feature(arbitrary_self_types, async_await)]
#![feature(arbitrary_self_types)]
use std::task::{self, Poll};
use std::future::Future;

3
src/test/ui/async-await/issues/issue-54752-async-block.rs
View file

@ -3,7 +3,4 @@
// edition:2018
// pp-exact
#![feature(async_await)]
#![allow(unused_parens)]
fn main() { let _a = (async { }); }

2
src/test/ui/async-await/issues/issue-54974.rs
View file

@ -1,8 +1,6 @@
// build-pass (FIXME(62277): could be check-pass?)
// edition:2018
#![feature(async_await)]
use std::sync::Arc;
trait SomeTrait: Send + Sync + 'static {

3
src/test/ui/async-await/issues/issue-55324.rs
View file

@ -1,11 +1,8 @@
// build-pass (FIXME(62277): could be check-pass?)
// edition:2018
#![feature(async_await)]
use std::future::Future;
#[allow(unused)]
async fn foo<F: Future<Output = i32>>(x: &i32, future: F) -> i32 {
let y = future.await;
*x + y

2
src/test/ui/async-await/issues/issue-55809.rs
View file

@ -1,8 +1,6 @@
// edition:2018
// run-pass
#![feature(async_await)]
trait Foo { }
impl Foo for () { }

2
src/test/ui/async-await/issues/issue-58885.rs
View file

@ -1,8 +1,6 @@
// build-pass (FIXME(62277): could be check-pass?)
// edition:2018
#![feature(async_await)]
struct Xyz {
a: u64,
}

3
src/test/ui/async-await/issues/issue-59001.rs
View file

@ -1,11 +1,8 @@
// build-pass (FIXME(62277): could be check-pass?)
// edition:2018
#![feature(async_await)]
use std::future::Future;
#[allow(unused)]
async fn enter<'a, F, R>(mut callback: F)
where
F: FnMut(&'a mut i32) -> R,

6
src/test/ui/async-await/issues/issue-59972.rs
View file

@ -6,8 +6,6 @@
// compile-flags: --edition=2018
#![feature(async_await)]
pub enum Uninhabited { }
fn uninhabited_async() -> Uninhabited {
@ -16,14 +14,12 @@ fn uninhabited_async() -> Uninhabited {
async fn noop() { }
#[allow(unused)]
async fn contains_never() {
let error = uninhabited_async();
noop().await;
let error2 = error;
}
#[allow(unused)]
async fn overlap_never() {
let error1 = uninhabited_async();
noop().await;
@ -35,6 +31,4 @@ async fn overlap_never() {
#[allow(unused_must_use)]
fn main() {
contains_never();
overlap_never();
}

2
src/test/ui/async-await/issues/issue-60518.rs
View file

@ -1,8 +1,6 @@
// build-pass (FIXME(62277): could be check-pass?)
// edition:2018
#![feature(async_await)]
// This is a regression test to ensure that simple bindings (where replacement arguments aren't
// created during async fn lowering) that have their DefId used during HIR lowering (such as impl
// trait) are visited during def collection and thus have a DefId.

1
src/test/ui/async-await/issues/issue-60655-latebound-regions.rs
View file

@ -3,7 +3,6 @@
// build-pass (FIXME(62277): could be check-pass?)
// edition:2018
#![feature(async_await)]
#![feature(type_alias_impl_trait)]
use std::future::Future;

1
src/test/ui/async-await/issues/issue-60674.rs
View file

@ -1,7 +1,6 @@
// aux-build:issue-60674.rs
// build-pass (FIXME(62277): could be check-pass?)
// edition:2018
#![feature(async_await)]
// This is a regression test that ensures that `mut` patterns are not lost when provided as input
// to a proc macro.

4
src/test/ui/async-await/issues/issue-61187.rs
View file

@ -1,8 +1,6 @@
// edition:2018
#![feature(async_await)]
fn main() {
}
fn main() {}
async fn response(data: Vec<u8>) {
data.reverse(); //~ ERROR E0596

2
src/test/ui/async-await/issues/issue-61187.stderr
View file

@ -1,5 +1,5 @@
error[E0596]: cannot borrow `data` as mutable, as it is not declared as mutable
--> $DIR/issue-61187.rs:8:5
--> $DIR/issue-61187.rs:6:5
|
LL | async fn response(data: Vec<u8>) {
| ---- help: consider changing this to be mutable: `mut data`

2
src/test/ui/async-await/issues/issue-61986.rs
View file

@ -4,8 +4,6 @@
// Tests that we properly handle StorageDead/StorageLives for temporaries
// created in async loop bodies.
#![feature(async_await)]
async fn bar() -> Option<()> {
Some(())
}

2
src/test/ui/async-await/issues/issue-62009-1.rs
View file

@ -1,7 +1,5 @@
// edition:2018
#![feature(async_await)]
async fn print_dur() {}
fn main() {

12
src/test/ui/async-await/issues/issue-62009-1.stderr
View file

@ -1,5 +1,5 @@
error[E0728]: `await` is only allowed inside `async` functions and blocks
--> $DIR/issue-62009-1.rs:8:5
--> $DIR/issue-62009-1.rs:6:5
|
LL | fn main() {
| ---- this is not `async`
@ -7,7 +7,7 @@ LL | async { let (); }.await;
| ^^^^^^^^^^^^^^^^^^^^^^^ only allowed inside `async` functions and blocks
error[E0728]: `await` is only allowed inside `async` functions and blocks
--> $DIR/issue-62009-1.rs:10:5
--> $DIR/issue-62009-1.rs:8:5
|
LL | fn main() {
| ---- this is not `async`
@ -19,7 +19,7 @@ LL | | }.await;
| |___________^ only allowed inside `async` functions and blocks
error[E0728]: `await` is only allowed inside `async` functions and blocks
--> $DIR/issue-62009-1.rs:14:5
--> $DIR/issue-62009-1.rs:12:5
|
LL | fn main() {
| ---- this is not `async`
@ -27,11 +27,11 @@ LL | fn main() {
LL | (|_| 2333).await;
| ^^^^^^^^^^^^^^^^ only allowed inside `async` functions and blocks
error[E0277]: the trait bound `[closure@$DIR/issue-62009-1.rs:14:5: 14:15]: std::future::Future` is not satisfied
--> $DIR/issue-62009-1.rs:14:5
error[E0277]: the trait bound `[closure@$DIR/issue-62009-1.rs:12:5: 12:15]: std::future::Future` is not satisfied
--> $DIR/issue-62009-1.rs:12:5
|
LL | (|_| 2333).await;
| ^^^^^^^^^^^^^^^^ the trait `std::future::Future` is not implemented for `[closure@$DIR/issue-62009-1.rs:14:5: 14:15]`
| ^^^^^^^^^^^^^^^^ the trait `std::future::Future` is not implemented for `[closure@$DIR/issue-62009-1.rs:12:5: 12:15]`
|
= note: required by `std::future::poll_with_tls_context`

2
src/test/ui/async-await/issues/issue-62009-2.rs
View file

@ -1,6 +1,6 @@
// edition:2018
#![feature(async_await, async_closure)]
#![feature(async_closure)]
async fn print_dur() {}

2
src/test/ui/async-await/issues/issue-62517-1.rs
View file

@ -5,8 +5,6 @@
// edition:2018
// check-pass
#![feature(async_await)]
trait FirstTrait {}
trait SecondTrait {
type Item: ?Sized;

Some files were not shown because too many files have changed in this diff Show more