bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Auto merge of #66141 - Centril:rollup-n2fcvp9, r=Centril

Browse source 
Rollup of 11 pull requests

Successful merges:

 - #65892 (Remove `PartialEq` and `Eq` from the `SpecialDerives`.)
 - #66014 (Show type parameter name and definition in type mismatch error messages )
 - #66027 (Move has_panic_handler to query)
 - #66054 (syntax: Avoid span arithmetic for delimiter tokens)
 - #66068 (use silent emitter for rustdoc highlighting pass)
 - #66081 (let caller of check_ptr_access_align control the error message)
 - #66093 (Do not ICE with a precision flag in formatting str and no format arguments)
 - #66098 (Detect `::` -> `:` typo when involving turbofish)
 - #66101 (Tweak type mismatch caused by break on tail expr)
 - #66106 (Fix typo in explanation of `E0080`)
 - #66115 (rustc: remove "GlobalMetaData" dead code from hir::map::definitions.)

Failed merges:

r? @ghost
This commit is contained in:
bors 2019-11-06 02:29:21 +00:00
commit e4931eaaa3
96 changed files with 453 additions and 466 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/librustc/error_codes.rs
View file

@ -335,7 +335,7 @@ This works because `Box` is a pointer, so its size is well-known.
"##, "##,
E0080: r##" E0080: r##"
This error indicates that the compiler was unable to sensibly evaluate an This error indicates that the compiler was unable to sensibly evaluate a
constant expression that had to be evaluated. Attempting to divide by 0 constant expression that had to be evaluated. Attempting to divide by 0
or causing integer overflow are two ways to induce this error. For example: or causing integer overflow are two ways to induce this error. For example:

3
src/librustc/hir/lowering.rs
View file

@ -65,7 +65,6 @@ use syntax::ast;
use syntax::ptr::P as AstP; use syntax::ptr::P as AstP;
use syntax::ast::*; use syntax::ast::*;
use syntax::errors; use syntax::errors;
use syntax::expand::SpecialDerives;
use syntax::print::pprust; use syntax::print::pprust;
use syntax::parse::token::{self, Nonterminal, Token}; use syntax::parse::token::{self, Nonterminal, Token};
use syntax::tokenstream::{TokenStream, TokenTree}; use syntax::tokenstream::{TokenStream, TokenTree};
@ -184,8 +183,6 @@ pub trait Resolver {
ns: Namespace, ns: Namespace,
) -> (ast::Path, Res<NodeId>); ) -> (ast::Path, Res<NodeId>);
fn has_derives(&self, node_id: NodeId, derives: SpecialDerives) -> bool;
fn lint_buffer(&mut self) -> &mut lint::LintBuffer; fn lint_buffer(&mut self) -> &mut lint::LintBuffer;
} }

9
src/librustc/hir/lowering/item.rs
View file

@ -18,7 +18,6 @@ use smallvec::SmallVec;
use syntax::attr; use syntax::attr;
use syntax::ast::*; use syntax::ast::*;
use syntax::visit::{self, Visitor}; use syntax::visit::{self, Visitor};
use syntax::expand::SpecialDerives;
use syntax::source_map::{respan, DesugaringKind, Spanned}; use syntax::source_map::{respan, DesugaringKind, Spanned};
use syntax::symbol::{kw, sym}; use syntax::symbol::{kw, sym};
use syntax_pos::Span; use syntax_pos::Span;
@ -227,13 +226,7 @@ impl LoweringContext<'_> {
pub fn lower_item(&mut self, i: &Item) -> Option<hir::Item> { pub fn lower_item(&mut self, i: &Item) -> Option<hir::Item> {
let mut ident = i.ident; let mut ident = i.ident;
let mut vis = self.lower_visibility(&i.vis, None); let mut vis = self.lower_visibility(&i.vis, None);
let mut attrs = self.lower_attrs_extendable(&i.attrs); let attrs = self.lower_attrs(&i.attrs);
if self.resolver.has_derives(i.id, SpecialDerives::PARTIAL_EQ | SpecialDerives::EQ) {
// Add `#[structural_match]` if the item derived both `PartialEq` and `Eq`.
let ident = Ident::new(sym::structural_match, i.span);
attrs.push(attr::mk_attr_outer(attr::mk_word_item(ident)));
}
let attrs = attrs.into();
if let ItemKind::MacroDef(ref def) = i.kind { if let ItemKind::MacroDef(ref def) = i.kind {
if !def.legacy || attr::contains_name(&i.attrs, sym::macro_export) { if !def.legacy || attr::contains_name(&i.attrs, sym::macro_export) {

90
src/librustc/hir/map/definitions.rs
View file

@ -19,7 +19,7 @@ use std::hash::Hash;
use syntax::ast; use syntax::ast;
use syntax_pos::symbol::{Symbol, sym}; use syntax_pos::symbol::{Symbol, sym};
use syntax_pos::hygiene::ExpnId; use syntax_pos::hygiene::ExpnId;
use syntax_pos::{Span, DUMMY_SP}; use syntax_pos::Span;
/// The `DefPathTable` maps `DefIndex`es to `DefKey`s and vice versa. /// The `DefPathTable` maps `DefIndex`es to `DefKey`s and vice versa.
/// Internally the `DefPathTable` holds a tree of `DefKey`s, where each `DefKey` /// Internally the `DefPathTable` holds a tree of `DefKey`s, where each `DefKey`
@ -310,10 +310,6 @@ pub enum DefPathData {
AnonConst, AnonConst,
/// An `impl Trait` type node. /// An `impl Trait` type node.
ImplTrait, ImplTrait,
/// Identifies a piece of crate metadata that is global to a whole crate
/// (as opposed to just one item). `GlobalMetaData` components are only
/// supposed to show up right below the crate root.
GlobalMetaData(Symbol),
} }
#[derive(Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, Debug, #[derive(Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, Debug,
@ -444,9 +440,6 @@ impl Definitions {
self.node_to_def_index.insert(ast::CRATE_NODE_ID, root_index); self.node_to_def_index.insert(ast::CRATE_NODE_ID, root_index);
self.set_invocation_parent(ExpnId::root(), root_index); self.set_invocation_parent(ExpnId::root(), root_index);
// Allocate some other `DefIndex`es that always must exist.
GlobalMetaDataKind::allocate_def_indices(self);
root_index root_index
} }
@ -553,8 +546,7 @@ impl DefPathData {
TypeNs(name) | TypeNs(name) |
ValueNs(name) | ValueNs(name) |
MacroNs(name) | MacroNs(name) |
LifetimeNs(name) | LifetimeNs(name) => Some(name),
GlobalMetaData(name) => Some(name),
Impl | Impl |
CrateRoot | CrateRoot |
@ -572,8 +564,7 @@ impl DefPathData {
TypeNs(name) | TypeNs(name) |
ValueNs(name) | ValueNs(name) |
MacroNs(name) | MacroNs(name) |
LifetimeNs(name) | LifetimeNs(name) => {
GlobalMetaData(name) => {
name name
} }
// Note that this does not show up in user print-outs. // Note that this does not show up in user print-outs.
@ -591,78 +582,3 @@ impl DefPathData {
self.as_symbol().to_string() self.as_symbol().to_string()
} }
} }
// We define the `GlobalMetaDataKind` enum with this macro because we want to
// make sure that we exhaustively iterate over all variants when registering
// the corresponding `DefIndex`es in the `DefTable`.
macro_rules! define_global_metadata_kind {
(pub enum GlobalMetaDataKind {
$($variant:ident),*
}) => (
pub enum GlobalMetaDataKind {
$($variant),*
}
impl GlobalMetaDataKind {
fn allocate_def_indices(definitions: &mut Definitions) {
$({
let instance = GlobalMetaDataKind::$variant;
definitions.create_def_with_parent(
CRATE_DEF_INDEX,
ast::DUMMY_NODE_ID,
DefPathData::GlobalMetaData(instance.name()),
ExpnId::root(),
DUMMY_SP
);
// Make sure calling `def_index` does not crash.
instance.def_index(&definitions.table);
})*
}
pub fn def_index(&self, def_path_table: &DefPathTable) -> DefIndex {
let def_key = DefKey {
parent: Some(CRATE_DEF_INDEX),
disambiguated_data: DisambiguatedDefPathData {
data: DefPathData::GlobalMetaData(self.name()),
disambiguator: 0,
}
};
// These `DefKey`s are all right after the root,
// so a linear search is fine.
let index = def_path_table.index_to_key
.iter()
.position(|k| *k == def_key)
.unwrap();
DefIndex::from(index)
}
fn name(&self) -> Symbol {
let string = match *self {
$(
GlobalMetaDataKind::$variant => {
concat!("{{GlobalMetaData::", stringify!($variant), "}}")
}
)*
};
Symbol::intern(string)
}
}
)
}
define_global_metadata_kind!(pub enum GlobalMetaDataKind {
Krate,
CrateDeps,
DylibDependencyFormats,
LangItems,
LangItemsMissing,
NativeLibraries,
SourceMap,
Impls,
ExportedSymbols
});

10
src/librustc/infer/error_reporting/mod.rs
View file

@ -1234,8 +1234,16 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
} }
} }
// In some (most?) cases cause.body_id points to actual body, but in some cases
// it's a actual definition. According to the comments (e.g. in
// librustc_typeck/check/compare_method.rs:compare_predicate_entailment) the latter
// is relied upon by some other code. This might (or might not) need cleanup.
let body_owner_def_id = self.tcx.hir().opt_local_def_id(cause.body_id)
.unwrap_or_else(|| {
self.tcx.hir().body_owner_def_id(hir::BodyId { hir_id: cause.body_id })
});
self.check_and_note_conflicting_crates(diag, terr, span); self.check_and_note_conflicting_crates(diag, terr, span);
self.tcx.note_and_explain_type_err(diag, terr, span); self.tcx.note_and_explain_type_err(diag, terr, span, body_owner_def_id);
// It reads better to have the error origin as the final // It reads better to have the error origin as the final
// thing. // thing.

4
src/librustc/session/mod.rs
View file

@ -148,9 +148,6 @@ pub struct Session {
/// Metadata about the allocators for the current crate being compiled. /// Metadata about the allocators for the current crate being compiled.
pub has_global_allocator: Once<bool>, pub has_global_allocator: Once<bool>,
/// Metadata about the panic handlers for the current crate being compiled.
pub has_panic_handler: Once<bool>,
/// Cap lint level specified by a driver specifically. /// Cap lint level specified by a driver specifically.
pub driver_lint_caps: FxHashMap<lint::LintId, lint::Level>, pub driver_lint_caps: FxHashMap<lint::LintId, lint::Level>,
@ -1211,7 +1208,6 @@ fn build_session_(
print_fuel, print_fuel,
jobserver: jobserver::client(), jobserver: jobserver::client(),
has_global_allocator: Once::new(), has_global_allocator: Once::new(),
has_panic_handler: Once::new(),
driver_lint_caps, driver_lint_caps,
trait_methods_not_found: Lock::new(Default::default()), trait_methods_not_found: Lock::new(Default::default()),
confused_type_with_std_module: Lock::new(Default::default()), confused_type_with_std_module: Lock::new(Default::default()),

2
src/librustc/traits/error_reporting.rs
View file

@ -1231,7 +1231,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
fn suggest_fn_call( fn suggest_fn_call(
&self, &self,
obligation: &PredicateObligation<'tcx>, obligation: &PredicateObligation<'tcx>,
err: &mut DiagnosticBuilder<'tcx>, err: &mut DiagnosticBuilder<'_>,
trait_ref: &ty::Binder<ty::TraitRef<'tcx>>, trait_ref: &ty::Binder<ty::TraitRef<'tcx>>,
points_at_arg: bool, points_at_arg: bool,
) { ) {

5
src/librustc/ty/context.rs
View file

@ -3045,4 +3045,9 @@ pub fn provide(providers: &mut ty::query::Providers<'_>) {
assert_eq!(cnum, LOCAL_CRATE); assert_eq!(cnum, LOCAL_CRATE);
attr::contains_name(tcx.hir().krate_attrs(), sym::compiler_builtins) attr::contains_name(tcx.hir().krate_attrs(), sym::compiler_builtins)
}; };
providers.has_panic_handler = |tcx, cnum| {
assert_eq!(cnum, LOCAL_CRATE);
// We want to check if the panic handler was defined in this crate
tcx.lang_items().panic_impl().map_or(false, |did| did.is_local())
};
} }

21
src/librustc/ty/error.rs
View file

@ -241,7 +241,7 @@ impl<'tcx> ty::TyS<'tcx> {
ty::Infer(ty::FreshFloatTy(_)) => "fresh floating-point type".into(), ty::Infer(ty::FreshFloatTy(_)) => "fresh floating-point type".into(),
ty::Projection(_) => "associated type".into(), ty::Projection(_) => "associated type".into(),
ty::UnnormalizedProjection(_) => "non-normalized associated type".into(), ty::UnnormalizedProjection(_) => "non-normalized associated type".into(),
ty::Param(_) => "type parameter".into(), ty::Param(p) => format!("type parameter `{}`", p).into(),
ty::Opaque(..) => "opaque type".into(), ty::Opaque(..) => "opaque type".into(),
ty::Error => "type error".into(), ty::Error => "type error".into(),
} }
@ -254,6 +254,7 @@ impl<'tcx> TyCtxt<'tcx> {
db: &mut DiagnosticBuilder<'_>, db: &mut DiagnosticBuilder<'_>,
err: &TypeError<'tcx>, err: &TypeError<'tcx>,
sp: Span, sp: Span,
body_owner_def_id: DefId,
) { ) {
use self::TypeError::*; use self::TypeError::*;
@ -288,7 +289,16 @@ impl<'tcx> TyCtxt<'tcx> {
); );
} }
}, },
(ty::Param(_), ty::Param(_)) => { (ty::Param(expected), ty::Param(found)) => {
let generics = self.generics_of(body_owner_def_id);
let e_span = self.def_span(generics.type_param(expected, self).def_id);
if !sp.contains(e_span) {
db.span_label(e_span, "expected type parameter");
}
let f_span = self.def_span(generics.type_param(found, self).def_id);
if !sp.contains(f_span) {
db.span_label(f_span, "found type parameter");
}
db.note("a type parameter was expected, but a different one was found; \ db.note("a type parameter was expected, but a different one was found; \
you might be missing a type parameter or trait bound"); you might be missing a type parameter or trait bound");
db.note("for more information, visit \ db.note("for more information, visit \
@ -301,7 +311,12 @@ impl<'tcx> TyCtxt<'tcx> {
(ty::Param(_), ty::Projection(_)) | (ty::Projection(_), ty::Param(_)) => { (ty::Param(_), ty::Projection(_)) | (ty::Projection(_), ty::Param(_)) => {
db.note("you might be missing a type parameter or trait bound"); db.note("you might be missing a type parameter or trait bound");
} }
(ty::Param(_), _) | (_, ty::Param(_)) => { (ty::Param(p), _) | (_, ty::Param(p)) => {
let generics = self.generics_of(body_owner_def_id);
let p_span = self.def_span(generics.type_param(p, self).def_id);
if !sp.contains(p_span) {
db.span_label(p_span, "this type parameter");
}
db.help("type parameters must be constrained to match other types"); db.help("type parameters must be constrained to match other types");
if self.sess.teach(&db.get_code().unwrap()) { if self.sess.teach(&db.get_code().unwrap()) {
db.help("given a type parameter `T` and a method `foo`: db.help("given a type parameter `T` and a method `foo`:

3
src/librustc_codegen_utils/symbol_names/v0.rs
View file

@ -601,8 +601,7 @@ impl Printer<'tcx> for SymbolMangler<'tcx> {
| DefPathData::Misc | DefPathData::Misc
| DefPathData::Impl | DefPathData::Impl
| DefPathData::MacroNs(_) | DefPathData::MacroNs(_)
| DefPathData::LifetimeNs(_) | DefPathData::LifetimeNs(_) => {
| DefPathData::GlobalMetaData(_) => {
bug!("symbol_names: unexpected DefPathData: {:?}", disambiguated_data.data) bug!("symbol_names: unexpected DefPathData: {:?}", disambiguated_data.data)
} }
}; };

8
src/librustc_errors/emitter.rs
View file

@ -424,6 +424,14 @@ impl Emitter for EmitterWriter {
} }
} }
/// An emitter that does nothing when emitting a diagnostic.
pub struct SilentEmitter;
impl Emitter for SilentEmitter {
fn source_map(&self) -> Option<&Lrc<SourceMapperDyn>> { None }
fn emit_diagnostic(&mut self, _: &Diagnostic) {}
}
/// maximum number of lines we will print for each error; arbitrary. /// maximum number of lines we will print for each error; arbitrary.
pub const MAX_HIGHLIGHT_LINES: usize = 6; pub const MAX_HIGHLIGHT_LINES: usize = 6;
/// maximum number of suggestions to be shown /// maximum number of suggestions to be shown

14
src/librustc_interface/interface.rs
View file

@ -17,10 +17,9 @@ use std::sync::{Arc, Mutex};
use syntax::{self, parse}; use syntax::{self, parse};
use syntax::ast::{self, MetaItemKind}; use syntax::ast::{self, MetaItemKind};
use syntax::parse::token; use syntax::parse::token;
use syntax::source_map::{FileName, FilePathMapping, FileLoader, SourceMap}; use syntax::source_map::{FileName, FileLoader, SourceMap};
use syntax::sess::ParseSess; use syntax::sess::ParseSess;
use syntax_pos::edition; use syntax_pos::edition;
use rustc_errors::{Diagnostic, emitter::Emitter, Handler, SourceMapperDyn};
pub type Result<T> = result::Result<T, ErrorReported>; pub type Result<T> = result::Result<T, ErrorReported>;
@ -63,18 +62,9 @@ impl Compiler {
/// Converts strings provided as `--cfg [cfgspec]` into a `crate_cfg`. /// Converts strings provided as `--cfg [cfgspec]` into a `crate_cfg`.
pub fn parse_cfgspecs(cfgspecs: Vec<String>) -> FxHashSet<(String, Option<String>)> { pub fn parse_cfgspecs(cfgspecs: Vec<String>) -> FxHashSet<(String, Option<String>)> {
struct NullEmitter;
impl Emitter for NullEmitter {
fn emit_diagnostic(&mut self, _: &Diagnostic) {}
fn source_map(&self) -> Option<&Lrc<SourceMapperDyn>> { None }
}
syntax::with_default_globals(move || { syntax::with_default_globals(move || {
let cfg = cfgspecs.into_iter().map(|s| { let cfg = cfgspecs.into_iter().map(|s| {
let sess = ParseSess::with_silent_emitter();
let cm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
let handler = Handler::with_emitter(false, None, Box::new(NullEmitter));
let sess = ParseSess::with_span_handler(handler, cm);
let filename = FileName::cfg_spec_source_code(&s); let filename = FileName::cfg_spec_source_code(&s);
let mut parser = parse::new_parser_from_source_str(&sess, filename, s.to_string()); let mut parser = parse::new_parser_from_source_str(&sess, filename, s.to_string());

3
src/librustc_metadata/encoder.rs
View file

@ -542,7 +542,6 @@ impl<'tcx> EncodeContext<'tcx> {
let attrs = tcx.hir().krate_attrs(); let attrs = tcx.hir().krate_attrs();
let has_default_lib_allocator = attr::contains_name(&attrs, sym::default_lib_allocator); let has_default_lib_allocator = attr::contains_name(&attrs, sym::default_lib_allocator);
let has_global_allocator = *tcx.sess.has_global_allocator.get(); 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), name: tcx.crate_name(LOCAL_CRATE),
@ -553,7 +552,7 @@ impl<'tcx> EncodeContext<'tcx> {
panic_strategy: tcx.sess.panic_strategy(), panic_strategy: tcx.sess.panic_strategy(),
edition: tcx.sess.edition(), edition: tcx.sess.edition(),
has_global_allocator: has_global_allocator, has_global_allocator: has_global_allocator,
has_panic_handler: has_panic_handler, has_panic_handler: tcx.has_panic_handler(LOCAL_CRATE),
has_default_lib_allocator: has_default_lib_allocator, has_default_lib_allocator: has_default_lib_allocator,
plugin_registrar_fn: tcx.plugin_registrar_fn(LOCAL_CRATE).map(|id| id.index), plugin_registrar_fn: tcx.plugin_registrar_fn(LOCAL_CRATE).map(|id| id.index),
proc_macro_decls_static: if is_proc_macro { proc_macro_decls_static: if is_proc_macro {

10
src/librustc_mir/interpret/memory.rs
View file

@ -314,16 +314,18 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
align: Align, align: Align,
) -> InterpResult<'tcx, Option<Pointer<M::PointerTag>>> { ) -> InterpResult<'tcx, Option<Pointer<M::PointerTag>>> {
let align = if M::CHECK_ALIGN { Some(align) } else { None }; let align = if M::CHECK_ALIGN { Some(align) } else { None };
self.check_ptr_access_align(sptr, size, align) self.check_ptr_access_align(sptr, size, align, CheckInAllocMsg::MemoryAccessTest)
} }
/// Like `check_ptr_access`, but *definitely* checks alignment when `align` /// Like `check_ptr_access`, but *definitely* checks alignment when `align`
/// is `Some` (overriding `M::CHECK_ALIGN`). /// is `Some` (overriding `M::CHECK_ALIGN`). Also lets the caller control
pub(super) fn check_ptr_access_align( /// the error message for the out-of-bounds case.
pub fn check_ptr_access_align(
&self, &self,
sptr: Scalar<M::PointerTag>, sptr: Scalar<M::PointerTag>,
size: Size, size: Size,
align: Option<Align>, align: Option<Align>,
msg: CheckInAllocMsg,
) -> InterpResult<'tcx, Option<Pointer<M::PointerTag>>> { ) -> InterpResult<'tcx, Option<Pointer<M::PointerTag>>> {
fn check_offset_align(offset: u64, align: Align) -> InterpResult<'static> { fn check_offset_align(offset: u64, align: Align) -> InterpResult<'static> {
if offset % align.bytes() == 0 { if offset % align.bytes() == 0 {
@ -368,7 +370,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
// It is sufficient to check this for the end pointer. The addition // It is sufficient to check this for the end pointer. The addition
// checks for overflow. // checks for overflow.
let end_ptr = ptr.offset(size, self)?; let end_ptr = ptr.offset(size, self)?;
end_ptr.check_inbounds_alloc(allocation_size, CheckInAllocMsg::MemoryAccessTest)?; end_ptr.check_inbounds_alloc(allocation_size, msg)?;
// Test align. Check this last; if both bounds and alignment are violated // Test align. Check this last; if both bounds and alignment are violated
// we want the error to be about the bounds. // we want the error to be about the bounds.
if let Some(align) = align { if let Some(align) = align {

9
src/librustc_mir/interpret/validity.rs
View file

@ -16,7 +16,7 @@ use rustc_data_structures::fx::FxHashSet;
use std::hash::Hash; use std::hash::Hash;
use super::{ use super::{
GlobalAlloc, InterpResult, GlobalAlloc, InterpResult, CheckInAllocMsg,
Scalar, OpTy, Machine, InterpCx, ValueVisitor, MPlaceTy, Scalar, OpTy, Machine, InterpCx, ValueVisitor, MPlaceTy,
}; };
@ -424,7 +424,12 @@ impl<'rt, 'mir, 'tcx, M: Machine<'mir, 'tcx>> ValueVisitor<'mir, 'tcx, M>
// alignment should take attributes into account). // alignment should take attributes into account).
.unwrap_or_else(|| (layout.size, layout.align.abi)); .unwrap_or_else(|| (layout.size, layout.align.abi));
let ptr: Option<_> = match let ptr: Option<_> = match
self.ecx.memory.check_ptr_access_align(ptr, size, Some(align)) self.ecx.memory.check_ptr_access_align(
ptr,
size,
Some(align),
CheckInAllocMsg::InboundsTest,
)
{ {
Ok(ptr) => ptr, Ok(ptr) => ptr,
Err(err) => { Err(err) => {

19
src/librustc_resolve/lib.rs
View file

@ -36,7 +36,6 @@ use rustc_metadata::creader::CrateLoader;
use rustc_metadata::cstore::CStore; use rustc_metadata::cstore::CStore;
use syntax::{struct_span_err, unwrap_or}; use syntax::{struct_span_err, unwrap_or};
use syntax::expand::SpecialDerives;
use syntax::ast::{self, Name, NodeId, Ident, FloatTy, IntTy, UintTy}; use syntax::ast::{self, Name, NodeId, Ident, FloatTy, IntTy, UintTy};
use syntax::ast::{CRATE_NODE_ID, Crate}; use syntax::ast::{CRATE_NODE_ID, Crate};
use syntax::ast::{ItemKind, Path}; use syntax::ast::{ItemKind, Path};
@ -934,12 +933,10 @@ pub struct Resolver<'a> {
multi_segment_macro_resolutions: Vec<(Vec<Segment>, Span, MacroKind, ParentScope<'a>, multi_segment_macro_resolutions: Vec<(Vec<Segment>, Span, MacroKind, ParentScope<'a>,
Option<Res>)>, Option<Res>)>,
builtin_attrs: Vec<(Ident, ParentScope<'a>)>, builtin_attrs: Vec<(Ident, ParentScope<'a>)>,
/// Some built-in derives mark items they are applied to so they are treated specially later. /// `derive(Copy)` marks items they are applied to so they are treated specially later.
/// Derive macros cannot modify the item themselves and have to store the markers in the global /// Derive macros cannot modify the item themselves and have to store the markers in the global
/// context, so they attach the markers to derive container IDs using this resolver table. /// context, so they attach the markers to derive container IDs using this resolver table.
/// FIXME: Find a way for `PartialEq` and `Eq` to emulate `#[structural_match]` containers_deriving_copy: FxHashSet<ExpnId>,
/// by marking the produced impls rather than the original items.
special_derives: FxHashMap<ExpnId, SpecialDerives>,
/// Parent scopes in which the macros were invoked. /// Parent scopes in which the macros were invoked.
/// FIXME: `derives` are missing in these parent scopes and need to be taken from elsewhere. /// FIXME: `derives` are missing in these parent scopes and need to be taken from elsewhere.
invocation_parent_scopes: FxHashMap<ExpnId, ParentScope<'a>>, invocation_parent_scopes: FxHashMap<ExpnId, ParentScope<'a>>,
@ -1078,12 +1075,6 @@ impl<'a> hir::lowering::Resolver for Resolver<'a> {
&mut self.definitions &mut self.definitions
} }
fn has_derives(&self, node_id: NodeId, derives: SpecialDerives) -> bool {
let def_id = self.definitions.local_def_id(node_id);
let expn_id = self.definitions.expansion_that_defined(def_id.index);
self.has_derives(expn_id, derives)
}
fn lint_buffer(&mut self) -> &mut lint::LintBuffer { fn lint_buffer(&mut self) -> &mut lint::LintBuffer {
&mut self.lint_buffer &mut self.lint_buffer
} }
@ -1228,7 +1219,7 @@ impl<'a> Resolver<'a> {
single_segment_macro_resolutions: Default::default(), single_segment_macro_resolutions: Default::default(),
multi_segment_macro_resolutions: Default::default(), multi_segment_macro_resolutions: Default::default(),
builtin_attrs: Default::default(), builtin_attrs: Default::default(),
special_derives: Default::default(), containers_deriving_copy: Default::default(),
active_features: active_features:
features.declared_lib_features.iter().map(|(feat, ..)| *feat) features.declared_lib_features.iter().map(|(feat, ..)| *feat)
.chain(features.declared_lang_features.iter().map(|(feat, ..)| *feat)) .chain(features.declared_lang_features.iter().map(|(feat, ..)| *feat))
@ -1314,10 +1305,6 @@ impl<'a> Resolver<'a> {
} }
} }
fn has_derives(&self, expn_id: ExpnId, markers: SpecialDerives) -> bool {
self.special_derives.get(&expn_id).map_or(false, |m| m.contains(markers))
}
/// Entry point to crate resolution. /// Entry point to crate resolution.
pub fn resolve_crate(&mut self, krate: &Crate) { pub fn resolve_crate(&mut self, krate: &Crate) {
let _prof_timer = let _prof_timer =

9
src/librustc_resolve/macros.rs
View file

@ -14,7 +14,6 @@ use rustc::{ty, lint, span_bug};
use syntax::ast::{self, NodeId, Ident}; use syntax::ast::{self, NodeId, Ident};
use syntax::attr::StabilityLevel; use syntax::attr::StabilityLevel;
use syntax::edition::Edition; use syntax::edition::Edition;
use syntax::expand::SpecialDerives;
use syntax::feature_gate::{emit_feature_err, is_builtin_attr_name}; use syntax::feature_gate::{emit_feature_err, is_builtin_attr_name};
use syntax::feature_gate::GateIssue; use syntax::feature_gate::GateIssue;
use syntax::print::pprust; use syntax::print::pprust;
@ -255,12 +254,12 @@ impl<'a> base::Resolver for Resolver<'a> {
} }
} }
fn has_derives(&self, expn_id: ExpnId, derives: SpecialDerives) -> bool { fn has_derive_copy(&self, expn_id: ExpnId) -> bool {
self.has_derives(expn_id, derives) self.containers_deriving_copy.contains(&expn_id)
} }
fn add_derives(&mut self, expn_id: ExpnId, derives: SpecialDerives) { fn add_derive_copy(&mut self, expn_id: ExpnId) {
*self.special_derives.entry(expn_id).or_default() |= derives; self.containers_deriving_copy.insert(expn_id);
} }
} }

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

@ -553,7 +553,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
pub fn check_for_cast( pub fn check_for_cast(
&self, &self,
err: &mut DiagnosticBuilder<'tcx>, err: &mut DiagnosticBuilder<'_>,
expr: &hir::Expr, expr: &hir::Expr,
checked_ty: Ty<'tcx>, checked_ty: Ty<'tcx>,
expected_ty: Ty<'tcx>, expected_ty: Ty<'tcx>,

10
src/librustc_typeck/check/expr.rs
View file

@ -583,7 +583,15 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
} else { } else {
assert!(e_ty.is_unit()); assert!(e_ty.is_unit());
let ty = coerce.expected_ty(); let ty = coerce.expected_ty();
coerce.coerce_forced_unit(self, &cause, &mut |err| { coerce.coerce_forced_unit(self, &cause, &mut |mut err| {
self.suggest_mismatched_types_on_tail(
&mut err,
expr,
ty,
e_ty,
cause.span,
target_id,
);
let val = match ty.kind { let val = match ty.kind {
ty::Bool => "true", ty::Bool => "true",
ty::Char => "'a'", ty::Char => "'a'",

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

@ -1267,11 +1267,6 @@ fn check_fn<'a, 'tcx>(
if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() { if let Some(panic_impl_did) = fcx.tcx.lang_items().panic_impl() {
if panic_impl_did == fcx.tcx.hir().local_def_id(fn_id) { if panic_impl_did == fcx.tcx.hir().local_def_id(fn_id) {
if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() { if let Some(panic_info_did) = fcx.tcx.lang_items().panic_info() {
// at this point we don't care if there are duplicate handlers or if the handler has
// the wrong signature as this value we'll be used when writing metadata and that
// only happens if compilation succeeded
fcx.tcx.sess.has_panic_handler.try_set_same(true);
if declared_ret_ty.kind != ty::Never { if declared_ret_ty.kind != ty::Never {
fcx.tcx.sess.span_err( fcx.tcx.sess.span_err(
decl.output.span(), decl.output.span(),
@ -4250,7 +4245,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
/// - Possible missing return type if the return type is the default, and not `fn main()`. /// - Possible missing return type if the return type is the default, and not `fn main()`.
pub fn suggest_mismatched_types_on_tail( pub fn suggest_mismatched_types_on_tail(
&self, &self,
err: &mut DiagnosticBuilder<'tcx>, err: &mut DiagnosticBuilder<'_>,
expr: &'tcx hir::Expr, expr: &'tcx hir::Expr,
expected: Ty<'tcx>, expected: Ty<'tcx>,
found: Ty<'tcx>, found: Ty<'tcx>,
@ -4277,7 +4272,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
/// ``` /// ```
fn suggest_fn_call( fn suggest_fn_call(
&self, &self,
err: &mut DiagnosticBuilder<'tcx>, err: &mut DiagnosticBuilder<'_>,
expr: &hir::Expr, expr: &hir::Expr,
expected: Ty<'tcx>, expected: Ty<'tcx>,
found: Ty<'tcx>, found: Ty<'tcx>,
@ -4390,7 +4385,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
pub fn suggest_ref_or_into( pub fn suggest_ref_or_into(
&self, &self,
err: &mut DiagnosticBuilder<'tcx>, err: &mut DiagnosticBuilder<'_>,
expr: &hir::Expr, expr: &hir::Expr,
expected: Ty<'tcx>, expected: Ty<'tcx>,
found: Ty<'tcx>, found: Ty<'tcx>,
@ -4458,7 +4453,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
/// in the heap by calling `Box::new()`. /// in the heap by calling `Box::new()`.
fn suggest_boxing_when_appropriate( fn suggest_boxing_when_appropriate(
&self, &self,
err: &mut DiagnosticBuilder<'tcx>, err: &mut DiagnosticBuilder<'_>,
expr: &hir::Expr, expr: &hir::Expr,
expected: Ty<'tcx>, expected: Ty<'tcx>,
found: Ty<'tcx>, found: Ty<'tcx>,
@ -4502,7 +4497,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
/// it suggests adding a semicolon. /// it suggests adding a semicolon.
fn suggest_missing_semicolon( fn suggest_missing_semicolon(
&self, &self,
err: &mut DiagnosticBuilder<'tcx>, err: &mut DiagnosticBuilder<'_>,
expression: &'tcx hir::Expr, expression: &'tcx hir::Expr,
expected: Ty<'tcx>, expected: Ty<'tcx>,
cause_span: Span, cause_span: Span,
@ -4541,7 +4536,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
/// type. /// type.
fn suggest_missing_return_type( fn suggest_missing_return_type(
&self, &self,
err: &mut DiagnosticBuilder<'tcx>, err: &mut DiagnosticBuilder<'_>,
fn_decl: &hir::FnDecl, fn_decl: &hir::FnDecl,
expected: Ty<'tcx>, expected: Ty<'tcx>,
found: Ty<'tcx>, found: Ty<'tcx>,
@ -4607,7 +4602,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
/// `.await` to the tail of the expression. /// `.await` to the tail of the expression.
fn suggest_missing_await( fn suggest_missing_await(
&self, &self,
err: &mut DiagnosticBuilder<'tcx>, err: &mut DiagnosticBuilder<'_>,
expr: &hir::Expr, expr: &hir::Expr,
expected: Ty<'tcx>, expected: Ty<'tcx>,
found: Ty<'tcx>, found: Ty<'tcx>,

4
src/librustdoc/html/highlight.rs
View file

@ -11,7 +11,7 @@ use std::fmt::Display;
use std::io; use std::io;
use std::io::prelude::*; use std::io::prelude::*;
use syntax::source_map::{SourceMap, FilePathMapping}; use syntax::source_map::SourceMap;
use syntax::parse::lexer; use syntax::parse::lexer;
use syntax::parse::token::{self, Token}; use syntax::parse::token::{self, Token};
use syntax::sess::ParseSess; use syntax::sess::ParseSess;
@ -33,7 +33,7 @@ pub fn render_with_highlighting(
class, tooltip).unwrap(); class, tooltip).unwrap();
} }
let sess = ParseSess::new(FilePathMapping::empty()); let sess = ParseSess::with_silent_emitter();
let fm = sess.source_map().new_source_file( let fm = sess.source_map().new_source_file(
FileName::Custom(String::from("rustdoc-highlighting")), FileName::Custom(String::from("rustdoc-highlighting")),
src.to_owned(), src.to_owned(),

10
src/libsyntax/expand/mod.rs
View file

@ -5,16 +5,6 @@ use syntax_pos::symbol::sym;
pub mod allocator; pub mod allocator;
bitflags::bitflags! {
/// Built-in derives that need some extra tracking beyond the usual macro functionality.
#[derive(Default)]
pub struct SpecialDerives: u8 {
const PARTIAL_EQ = 1 << 0;
const EQ = 1 << 1;
const COPY = 1 << 2;
}
}
pub fn is_proc_macro_attr(attr: &Attribute) -> bool { pub fn is_proc_macro_attr(attr: &Attribute) -> bool {
[sym::proc_macro, sym::proc_macro_attribute, sym::proc_macro_derive] [sym::proc_macro, sym::proc_macro_attribute, sym::proc_macro_derive]
.iter().any(|kind| attr.check_name(*kind)) .iter().any(|kind| attr.check_name(*kind))

4
src/libsyntax/parse/parser.rs
View file

@ -209,12 +209,12 @@ impl TokenCursor {
loop { loop {
let tree = if !self.frame.open_delim { let tree = if !self.frame.open_delim {
self.frame.open_delim = true; self.frame.open_delim = true;
TokenTree::open_tt(self.frame.span.open, self.frame.delim) TokenTree::open_tt(self.frame.span, self.frame.delim)
} else if let Some(tree) = self.frame.tree_cursor.next() { } else if let Some(tree) = self.frame.tree_cursor.next() {
tree tree
} else if !self.frame.close_delim { } else if !self.frame.close_delim {
self.frame.close_delim = true; self.frame.close_delim = true;
TokenTree::close_tt(self.frame.span.close, self.frame.delim) TokenTree::close_tt(self.frame.span, self.frame.delim)
} else if let Some(frame) = self.stack.pop() { } else if let Some(frame) = self.stack.pop() {
self.frame = frame; self.frame = frame;
continue continue

15
src/libsyntax/parse/parser/diagnostics.rs
View file

@ -360,11 +360,11 @@ impl<'a> Parser<'a> {
} }
pub fn maybe_annotate_with_ascription( pub fn maybe_annotate_with_ascription(
&self, &mut self,
err: &mut DiagnosticBuilder<'_>, err: &mut DiagnosticBuilder<'_>,
maybe_expected_semicolon: bool, maybe_expected_semicolon: bool,
) { ) {
if let Some((sp, likely_path)) = self.last_type_ascription { if let Some((sp, likely_path)) = self.last_type_ascription.take() {
let sm = self.sess.source_map(); let sm = self.sess.source_map();
let next_pos = sm.lookup_char_pos(self.token.span.lo()); let next_pos = sm.lookup_char_pos(self.token.span.lo());
let op_pos = sm.lookup_char_pos(sp.hi()); let op_pos = sm.lookup_char_pos(sp.hi());
@ -1088,8 +1088,15 @@ impl<'a> Parser<'a> {
} }
pub(super) fn could_ascription_be_path(&self, node: &ast::ExprKind) -> bool { pub(super) fn could_ascription_be_path(&self, node: &ast::ExprKind) -> bool {
self.token.is_ident() && (self.token == token::Lt && // `foo:<bar`, likely a typoed turbofish.
if let ast::ExprKind::Path(..) = node { true } else { false } && self.look_ahead(1, |t| t.is_ident() && !t.is_reserved_ident())
) ||
self.token.is_ident() &&
match node {
// `foo::` → `foo:` or `foo.bar::` → `foo.bar:`
ast::ExprKind::Path(..) | ast::ExprKind::Field(..) => true,
_ => false,
} &&
!self.token.is_reserved_ident() && // v `foo:bar(baz)` !self.token.is_reserved_ident() && // v `foo:bar(baz)`
self.look_ahead(1, |t| t == &token::OpenDelim(token::Paren)) || self.look_ahead(1, |t| t == &token::OpenDelim(token::Paren)) ||
self.look_ahead(1, |t| t == &token::Lt) && // `foo:bar<baz` self.look_ahead(1, |t| t == &token::Lt) && // `foo:bar<baz`

1
src/libsyntax/parse/parser/stmt.rs
View file

@ -397,6 +397,7 @@ impl<'a> Parser<'a> {
} }
let stmt = match self.parse_full_stmt(false) { let stmt = match self.parse_full_stmt(false) {
Err(mut err) => { Err(mut err) => {
self.maybe_annotate_with_ascription(&mut err, false);
err.emit(); err.emit();
self.recover_stmt_(SemiColonMode::Ignore, BlockMode::Ignore); self.recover_stmt_(SemiColonMode::Ignore, BlockMode::Ignore);
Some(Stmt { Some(Stmt {

8
src/libsyntax/sess.rs
View file

@ -6,7 +6,7 @@ use crate::early_buffered_lints::{BufferedEarlyLint, BufferedEarlyLintId};
use crate::source_map::{SourceMap, FilePathMapping}; use crate::source_map::{SourceMap, FilePathMapping};
use crate::feature_gate::UnstableFeatures; use crate::feature_gate::UnstableFeatures;
use errors::{Applicability, Handler, ColorConfig, DiagnosticBuilder}; use errors::{Applicability, emitter::SilentEmitter, Handler, ColorConfig, DiagnosticBuilder};
use rustc_data_structures::fx::{FxHashSet, FxHashMap}; use rustc_data_structures::fx::{FxHashSet, FxHashMap};
use rustc_data_structures::sync::{Lrc, Lock, Once}; use rustc_data_structures::sync::{Lrc, Lock, Once};
use syntax_pos::{Symbol, Span, MultiSpan}; use syntax_pos::{Symbol, Span, MultiSpan};
@ -107,6 +107,12 @@ impl ParseSess {
} }
} }
pub fn with_silent_emitter() -> Self {
let cm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
let handler = Handler::with_emitter(false, None, Box::new(SilentEmitter));
ParseSess::with_span_handler(handler, cm)
}
#[inline] #[inline]
pub fn source_map(&self) -> &SourceMap { pub fn source_map(&self) -> &SourceMap {
&self.source_map &self.source_map

20
src/libsyntax/tokenstream.rs
View file

@ -15,7 +15,7 @@
use crate::parse::token::{self, DelimToken, Token, TokenKind}; use crate::parse::token::{self, DelimToken, Token, TokenKind};
use syntax_pos::{BytePos, Span, DUMMY_SP}; use syntax_pos::{Span, DUMMY_SP};
#[cfg(target_arch = "x86_64")] #[cfg(target_arch = "x86_64")]
use rustc_data_structures::static_assert_size; use rustc_data_structures::static_assert_size;
use rustc_data_structures::sync::Lrc; use rustc_data_structures::sync::Lrc;
@ -110,23 +110,13 @@ impl TokenTree {
} }
/// Returns the opening delimiter as a token tree. /// Returns the opening delimiter as a token tree.
pub fn open_tt(span: Span, delim: DelimToken) -> TokenTree { pub fn open_tt(span: DelimSpan, delim: DelimToken) -> TokenTree {
let open_span = if span.is_dummy() { TokenTree::token(token::OpenDelim(delim), span.open)
span
} else {
span.with_hi(span.lo() + BytePos(delim.len() as u32))
};
TokenTree::token(token::OpenDelim(delim), open_span)
} }
/// Returns the closing delimiter as a token tree. /// Returns the closing delimiter as a token tree.
pub fn close_tt(span: Span, delim: DelimToken) -> TokenTree { pub fn close_tt(span: DelimSpan, delim: DelimToken) -> TokenTree {
let close_span = if span.is_dummy() { TokenTree::token(token::CloseDelim(delim), span.close)
span
} else {
span.with_lo(span.hi() - BytePos(delim.len() as u32))
};
TokenTree::token(token::CloseDelim(delim), close_span)
} }
} }

5
src/libsyntax_expand/base.rs
View file

@ -13,7 +13,6 @@ use syntax::symbol::{kw, sym, Ident, Symbol};
use syntax::{ThinVec, MACRO_ARGUMENTS}; use syntax::{ThinVec, MACRO_ARGUMENTS};
use syntax::tokenstream::{self, TokenStream}; use syntax::tokenstream::{self, TokenStream};
use syntax::visit::Visitor; use syntax::visit::Visitor;
crate use syntax::expand::SpecialDerives;
use errors::{DiagnosticBuilder, DiagnosticId}; use errors::{DiagnosticBuilder, DiagnosticId};
use smallvec::{smallvec, SmallVec}; use smallvec::{smallvec, SmallVec};
@ -860,8 +859,8 @@ pub trait Resolver {
fn check_unused_macros(&mut self); fn check_unused_macros(&mut self);
fn has_derives(&self, expn_id: ExpnId, derives: SpecialDerives) -> bool; fn has_derive_copy(&self, expn_id: ExpnId) -> bool;
fn add_derives(&mut self, expn_id: ExpnId, derives: SpecialDerives); fn add_derive_copy(&mut self, expn_id: ExpnId);
} }
#[derive(Clone)] #[derive(Clone)]

2
src/libsyntax_expand/expand.rs
View file

@ -432,7 +432,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
// can be in scope for all code produced by that container's expansion. // can be in scope for all code produced by that container's expansion.
item.visit_with(&mut MarkAttrs(&helper_attrs)); item.visit_with(&mut MarkAttrs(&helper_attrs));
if has_copy { if has_copy {
self.cx.resolver.add_derives(invoc.expansion_data.id, SpecialDerives::COPY); self.cx.resolver.add_derive_copy(invoc.expansion_data.id);
} }
let mut derive_placeholders = Vec::with_capacity(derives.len()); let mut derive_placeholders = Vec::with_capacity(derives.len());

24
src/libsyntax_expand/mbe.rs
View file

@ -13,7 +13,7 @@ use syntax::ast;
use syntax::parse::token::{self, Token, TokenKind}; use syntax::parse::token::{self, Token, TokenKind};
use syntax::tokenstream::{DelimSpan}; use syntax::tokenstream::{DelimSpan};
use syntax_pos::{BytePos, Span}; use syntax_pos::Span;
use rustc_data_structures::sync::Lrc; use rustc_data_structures::sync::Lrc;
@ -27,23 +27,13 @@ struct Delimited {
impl Delimited { impl Delimited {
/// Returns a `self::TokenTree` with a `Span` corresponding to the opening delimiter. /// Returns a `self::TokenTree` with a `Span` corresponding to the opening delimiter.
fn open_tt(&self, span: Span) -> TokenTree { fn open_tt(&self, span: DelimSpan) -> TokenTree {
let open_span = if span.is_dummy() { TokenTree::token(token::OpenDelim(self.delim), span.open)
span
} else {
span.with_hi(span.lo() + BytePos(self.delim.len() as u32))
};
TokenTree::token(token::OpenDelim(self.delim), open_span)
} }
/// Returns a `self::TokenTree` with a `Span` corresponding to the closing delimiter. /// Returns a `self::TokenTree` with a `Span` corresponding to the closing delimiter.
fn close_tt(&self, span: Span) -> TokenTree { fn close_tt(&self, span: DelimSpan) -> TokenTree {
let close_span = if span.is_dummy() { TokenTree::token(token::CloseDelim(self.delim), span.close)
span
} else {
span.with_lo(span.hi() - BytePos(self.delim.len() as u32))
};
TokenTree::token(token::CloseDelim(self.delim), close_span)
} }
} }
@ -138,10 +128,10 @@ impl TokenTree {
} }
(&TokenTree::Delimited(span, ref delimed), _) => { (&TokenTree::Delimited(span, ref delimed), _) => {
if index == 0 { if index == 0 {
return delimed.open_tt(span.open); return delimed.open_tt(span);
} }
if index == delimed.tts.len() + 1 { if index == delimed.tts.len() + 1 {
return delimed.close_tt(span.close); return delimed.close_tt(span);
} }
delimed.tts[index - 1].clone() delimed.tts[index - 1].clone()
} }

6
src/libsyntax_expand/mbe/macro_rules.rs
View file

@ -566,7 +566,7 @@ impl FirstSets {
} }
TokenTree::Delimited(span, ref delimited) => { TokenTree::Delimited(span, ref delimited) => {
build_recur(sets, &delimited.tts[..]); build_recur(sets, &delimited.tts[..]);
first.replace_with(delimited.open_tt(span.open)); first.replace_with(delimited.open_tt(span));
} }
TokenTree::Sequence(sp, ref seq_rep) => { TokenTree::Sequence(sp, ref seq_rep) => {
let subfirst = build_recur(sets, &seq_rep.tts[..]); let subfirst = build_recur(sets, &seq_rep.tts[..]);
@ -628,7 +628,7 @@ impl FirstSets {
return first; return first;
} }
TokenTree::Delimited(span, ref delimited) => { TokenTree::Delimited(span, ref delimited) => {
first.add_one(delimited.open_tt(span.open)); first.add_one(delimited.open_tt(span));
return first; return first;
} }
TokenTree::Sequence(sp, ref seq_rep) => { TokenTree::Sequence(sp, ref seq_rep) => {
@ -826,7 +826,7 @@ fn check_matcher_core(
} }
} }
TokenTree::Delimited(span, ref d) => { TokenTree::Delimited(span, ref d) => {
let my_suffix = TokenSet::singleton(d.close_tt(span.close)); let my_suffix = TokenSet::singleton(d.close_tt(span));
check_matcher_core(sess, features, attrs, first_sets, &d.tts, &my_suffix); check_matcher_core(sess, features, attrs, first_sets, &d.tts, &my_suffix);
// don't track non NT tokens // don't track non NT tokens
last.replace_with_irrelevant(); last.replace_with_irrelevant();

3
src/libsyntax_ext/deriving/clone.rs
View file

@ -3,7 +3,6 @@ use crate::deriving::generic::*;
use crate::deriving::generic::ty::*; use crate::deriving::generic::ty::*;
use syntax::ast::{self, Expr, GenericArg, Generics, ItemKind, MetaItem, VariantData}; use syntax::ast::{self, Expr, GenericArg, Generics, ItemKind, MetaItem, VariantData};
use syntax::expand::SpecialDerives;
use syntax_expand::base::{Annotatable, ExtCtxt}; use syntax_expand::base::{Annotatable, ExtCtxt};
use syntax::ptr::P; use syntax::ptr::P;
use syntax::symbol::{kw, sym, Symbol}; use syntax::symbol::{kw, sym, Symbol};
@ -37,7 +36,7 @@ pub fn expand_deriving_clone(cx: &mut ExtCtxt<'_>,
ItemKind::Struct(_, Generics { ref params, .. }) | ItemKind::Struct(_, Generics { ref params, .. }) |
ItemKind::Enum(_, Generics { ref params, .. }) => { ItemKind::Enum(_, Generics { ref params, .. }) => {
let container_id = cx.current_expansion.id.expn_data().parent; let container_id = cx.current_expansion.id.expn_data().parent;
if cx.resolver.has_derives(container_id, SpecialDerives::COPY) && if cx.resolver.has_derive_copy(container_id) &&
!params.iter().any(|param| match param.kind { !params.iter().any(|param| match param.kind {
ast::GenericParamKind::Type { .. } => true, ast::GenericParamKind::Type { .. } => true,
_ => false, _ => false,

3
src/libsyntax_ext/deriving/cmp/eq.rs
View file

@ -3,7 +3,6 @@ use crate::deriving::generic::*;
use crate::deriving::generic::ty::*; use crate::deriving::generic::ty::*;
use syntax::ast::{self, Ident, Expr, MetaItem, GenericArg}; use syntax::ast::{self, Ident, Expr, MetaItem, GenericArg};
use syntax::expand::SpecialDerives;
use syntax::ptr::P; use syntax::ptr::P;
use syntax::symbol::{sym, Symbol}; use syntax::symbol::{sym, Symbol};
use syntax_expand::base::{Annotatable, ExtCtxt}; use syntax_expand::base::{Annotatable, ExtCtxt};
@ -14,8 +13,6 @@ pub fn expand_deriving_eq(cx: &mut ExtCtxt<'_>,
mitem: &MetaItem, mitem: &MetaItem,
item: &Annotatable, item: &Annotatable,
push: &mut dyn FnMut(Annotatable)) { push: &mut dyn FnMut(Annotatable)) {
cx.resolver.add_derives(cx.current_expansion.id.expn_data().parent, SpecialDerives::EQ);
let inline = cx.meta_word(span, sym::inline); let inline = cx.meta_word(span, sym::inline);
let hidden = syntax::attr::mk_nested_word_item(Ident::new(sym::hidden, span)); let hidden = syntax::attr::mk_nested_word_item(Ident::new(sym::hidden, span));
let doc = syntax::attr::mk_list_item(Ident::new(sym::doc, span), vec![hidden]); let doc = syntax::attr::mk_list_item(Ident::new(sym::doc, span), vec![hidden]);

3
src/libsyntax_ext/deriving/cmp/partial_eq.rs
View file

@ -3,7 +3,6 @@ use crate::deriving::generic::*;
use crate::deriving::generic::ty::*; use crate::deriving::generic::ty::*;
use syntax::ast::{BinOpKind, Expr, MetaItem}; use syntax::ast::{BinOpKind, Expr, MetaItem};
use syntax::expand::SpecialDerives;
use syntax::ptr::P; use syntax::ptr::P;
use syntax::symbol::sym; use syntax::symbol::sym;
use syntax_expand::base::{Annotatable, ExtCtxt}; use syntax_expand::base::{Annotatable, ExtCtxt};
@ -14,8 +13,6 @@ pub fn expand_deriving_partial_eq(cx: &mut ExtCtxt<'_>,
mitem: &MetaItem, mitem: &MetaItem,
item: &Annotatable, item: &Annotatable,
push: &mut dyn FnMut(Annotatable)) { push: &mut dyn FnMut(Annotatable)) {
cx.resolver.add_derives(cx.current_expansion.id.expn_data().parent, SpecialDerives::PARTIAL_EQ);
// structures are equal if all fields are equal, and non equal, if // structures are equal if all fields are equal, and non equal, if
// any fields are not equal or if the enum variants are different // any fields are not equal or if the enum variants are different
fn cs_op(cx: &mut ExtCtxt<'_>, fn cs_op(cx: &mut ExtCtxt<'_>,

7
src/libsyntax_ext/deriving/generic/mod.rs
View file

@ -186,7 +186,6 @@ use rustc_target::spec::abi::Abi;
use syntax::ast::{self, BinOpKind, EnumDef, Expr, Generics, Ident, PatKind}; use syntax::ast::{self, BinOpKind, EnumDef, Expr, Generics, Ident, PatKind};
use syntax::ast::{VariantData, GenericParamKind, GenericArg}; use syntax::ast::{VariantData, GenericParamKind, GenericArg};
use syntax::attr; use syntax::attr;
use syntax::expand::SpecialDerives;
use syntax::source_map::respan; use syntax::source_map::respan;
use syntax::util::map_in_place::MapInPlace; use syntax::util::map_in_place::MapInPlace;
use syntax::ptr::P; use syntax::ptr::P;
@ -427,10 +426,8 @@ impl<'a> TraitDef<'a> {
} }
}; };
let container_id = cx.current_expansion.id.expn_data().parent; let container_id = cx.current_expansion.id.expn_data().parent;
let is_always_copy = let always_copy = has_no_type_params && cx.resolver.has_derive_copy(container_id);
cx.resolver.has_derives(container_id, SpecialDerives::COPY) && let use_temporaries = is_packed && always_copy;
has_no_type_params;
let use_temporaries = is_packed && is_always_copy;
let newitem = match item.kind { let newitem = match item.kind {
ast::ItemKind::Struct(ref struct_def, ref generics) => { ast::ItemKind::Struct(ref struct_def, ref generics) => {

10
src/libsyntax_ext/format.rs
View file

@ -374,10 +374,12 @@ impl<'a, 'b> Context<'a, 'b> {
format!("are {} arguments", count) format!("are {} arguments", count)
}, },
)); ));
e.span_label( if let Some(arg) = self.args.get(pos) {
self.args[pos].span, e.span_label(
"this parameter corresponds to the precision flag", arg.span,
); "this parameter corresponds to the precision flag",
);
}
zero_based_note = true; zero_based_note = true;
} }
_ => {} _ => {}

10
src/test/mir-opt/graphviz.rs
View file

@ -7,14 +7,14 @@ fn main() {}
// END RUST SOURCE // END RUST SOURCE
// START rustc.main.mir_map.0.dot // START rustc.main.mir_map.0.dot
// digraph Mir_0_12 { // The name here MUST be an ASCII identifier. // digraph Mir_0_3 { // The name here MUST be an ASCII identifier.
// graph [fontname="monospace"]; // graph [fontname="monospace"];
// node [fontname="monospace"]; // node [fontname="monospace"];
// edge [fontname="monospace"]; // edge [fontname="monospace"];
// label=<fn main() -&gt; ()<br align="left"/>>; // label=<fn main() -&gt; ()<br align="left"/>>;
// bb0__0_12 [shape="none", label=<<table border="0" cellborder="1" cellspacing="0"><tr><td bgcolor="gray" align="center" colspan="1">0</td></tr><tr><td align="left" balign="left">_0 = ()<br/></td></tr><tr><td align="left">goto</td></tr></table>>]; // bb0__0_3 [shape="none", label=<<table border="0" cellborder="1" cellspacing="0"><tr><td bgcolor="gray" align="center" colspan="1">0</td></tr><tr><td align="left" balign="left">_0 = ()<br/></td></tr><tr><td align="left">goto</td></tr></table>>];
// bb1__0_12 [shape="none", label=<<table border="0" cellborder="1" cellspacing="0"><tr><td bgcolor="gray" align="center" colspan="1">1</td></tr><tr><td align="left">resume</td></tr></table>>]; // bb1__0_3 [shape="none", label=<<table border="0" cellborder="1" cellspacing="0"><tr><td bgcolor="gray" align="center" colspan="1">1</td></tr><tr><td align="left">resume</td></tr></table>>];
// bb2__0_12 [shape="none", label=<<table border="0" cellborder="1" cellspacing="0"><tr><td bgcolor="gray" align="center" colspan="1">2</td></tr><tr><td align="left">return</td></tr></table>>]; // bb2__0_3 [shape="none", label=<<table border="0" cellborder="1" cellspacing="0"><tr><td bgcolor="gray" align="center" colspan="1">2</td></tr><tr><td align="left">return</td></tr></table>>];
// bb0__0_12 -> bb2__0_12 [label=""]; // bb0__0_3 -> bb2__0_3 [label=""];
// } // }
// END rustc.main.mir_map.0.dot // END rustc.main.mir_map.0.dot

2
src/test/mir-opt/inline-closure-borrows-arg.rs
View file

@ -20,7 +20,7 @@ fn foo<T: Copy>(_t: T, q: &i32) -> i32 {
// ... // ...
// bb0: { // bb0: {
// ... // ...
// _3 = [closure@HirId { owner: DefIndex(13), local_id: 31 }]; // _3 = [closure@HirId { owner: DefIndex(4), local_id: 31 }];
// ... // ...
// _4 = &_3; // _4 = &_3;
// ... // ...

2
src/test/mir-opt/inline-closure.rs
View file

@ -16,7 +16,7 @@ fn foo<T: Copy>(_t: T, q: i32) -> i32 {
// ... // ...
// bb0: { // bb0: {
// ... // ...
// _3 = [closure@HirId { owner: DefIndex(13), local_id: 15 }]; // _3 = [closure@HirId { owner: DefIndex(4), local_id: 15 }];
// ... // ...
// _4 = &_3; // _4 = &_3;
// ... // ...

2
src/test/mir-opt/retag.rs
View file

@ -100,7 +100,7 @@ fn main() {
// } // }
// END rustc.main.EraseRegions.after.mir // END rustc.main.EraseRegions.after.mir
// START rustc.main-{{closure}}.EraseRegions.after.mir // START rustc.main-{{closure}}.EraseRegions.after.mir
// fn main::{{closure}}#0(_1: &[closure@HirId { owner: DefIndex(22), local_id: 72 }], _2: &i32) -> &i32 { // fn main::{{closure}}#0(_1: &[closure@HirId { owner: DefIndex(13), local_id: 72 }], _2: &i32) -> &i32 {
// ... // ...
// bb0: { // bb0: {
// Retag([fn entry] _1); // Retag([fn entry] _1);

64
src/test/rustdoc-ui/invalid-syntax.stderr
View file

@ -222,67 +222,3 @@ warning: could not parse code block as Rust code
LL | /// \____/ LL | /// \____/
| ^^^^^^ | ^^^^^^
error: unknown start of token: \
--> <rustdoc-highlighting>:1:1
|
1 | \____/
| ^
error: unknown start of token: \
--> <rustdoc-highlighting>:1:1
|
1 | \_
| ^
error: unknown start of token: \
--> <rustdoc-highlighting>:1:1
|
1 | \_
| ^
error: unknown start of token: `
--> <rustdoc-highlighting>:1:1
|
1 | ```
| ^
|
help: Unicode character '`' (Grave Accent) looks like ''' (Single Quote), but it is not
|
1 | '``
| ^
error: unknown start of token: \
--> <rustdoc-highlighting>:2:1
|
2 | \_
| ^
error: unknown start of token: \
--> <rustdoc-highlighting>:1:1
|
1 | \_
| ^
error: unknown start of token: \
--> <rustdoc-highlighting>:1:1
|
1 | \_
| ^
error: unknown start of token: `
--> <rustdoc-highlighting>:3:30
|
3 | | ^^^^^^ did you mean `baz::foobar`?
| ^
|
help: Unicode character '`' (Grave Accent) looks like ''' (Single Quote), but it is not
|
3 | | ^^^^^^ did you mean 'baz::foobar`?
| ^
error: unknown start of token: \
--> <rustdoc-highlighting>:1:1
|
1 | \__________pkt->size___________/ \_result->size_/ \__pkt->size__/
| ^

5
src/test/ui/associated-types/associated-types-issue-20346.stderr
View file

@ -4,8 +4,11 @@ error[E0271]: type mismatch resolving `<Adapter<I> as Iterator>::Item == std::op
LL | fn is_iterator_of<A, I: Iterator<Item=A>>(_: &I) {} LL | fn is_iterator_of<A, I: Iterator<Item=A>>(_: &I) {}
| -------------- ------ required by this bound in `is_iterator_of` | -------------- ------ required by this bound in `is_iterator_of`
... ...
LL | fn test_adapter<T, I: Iterator<Item=Option<T>>>(it: I) {
| - this type parameter
...
LL | is_iterator_of::<Option<T>, _>(&adapter); LL | is_iterator_of::<Option<T>, _>(&adapter);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected enum `std::option::Option`, found type parameter | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected enum `std::option::Option`, found type parameter `T`
| |
= note: expected type `std::option::Option<T>` = note: expected type `std::option::Option<T>`
found type `T` found type `T`

5
src/test/ui/compare-method/reordered-type-param.stderr
View file

@ -5,7 +5,10 @@ LL | fn b<C:Clone,D>(&self, x: C) -> C;
| - type in trait | - type in trait
... ...
LL | fn b<F:Clone,G>(&self, _x: G) -> G { panic!() } LL | fn b<F:Clone,G>(&self, _x: G) -> G { panic!() }
| ^ expected type parameter, found a different type parameter | - - ^ expected type parameter `F`, found type parameter `G`
| | |
| | found type parameter
| expected type parameter
| |
= note: expected type `fn(&E, F) -> F` = note: expected type `fn(&E, F) -> F`
found type `fn(&E, G) -> G` found type `fn(&E, G) -> G`

5
src/test/ui/if/ifmt-bad-arg.rs
View file

@ -86,4 +86,9 @@ tenth number: {}",
println!("{:foo}", 1); //~ ERROR unknown format trait `foo` println!("{:foo}", 1); //~ ERROR unknown format trait `foo`
println!("{5} {:4$} {6:7$}", 1); println!("{5} {:4$} {6:7$}", 1);
//~^ ERROR invalid reference to positional arguments 4, 5, 6 and 7 (there is 1 argument) //~^ ERROR invalid reference to positional arguments 4, 5, 6 and 7 (there is 1 argument)
// We used to ICE here because we tried to unconditionally access the first argument, which
// doesn't exist.
println!("{:.*}");
//~^ ERROR 2 positional arguments in format string, but no arguments were given
} }

13
src/test/ui/if/ifmt-bad-arg.stderr
View file

@ -285,6 +285,17 @@ LL | println!("{5} {:4$} {6:7$}", 1);
= note: positional arguments are zero-based = note: positional arguments are zero-based
= note: for information about formatting flags, visit https://doc.rust-lang.org/std/fmt/index.html = note: for information about formatting flags, visit https://doc.rust-lang.org/std/fmt/index.html
error: 2 positional arguments in format string, but no arguments were given
--> $DIR/ifmt-bad-arg.rs:92:15
|
LL | println!("{:.*}");
| ^^--^
| |
| this precision flag adds an extra required argument at position 0, which is why there are 2 arguments expected
|
= note: positional arguments are zero-based
= note: for information about formatting flags, visit https://doc.rust-lang.org/std/fmt/index.html
error[E0308]: mismatched types error[E0308]: mismatched types
--> $DIR/ifmt-bad-arg.rs:78:32 --> $DIR/ifmt-bad-arg.rs:78:32
| |
@ -303,6 +314,6 @@ LL | println!("{} {:07$.*} {}", 1, 3.2, 4);
= note: expected type `&usize` = note: expected type `&usize`
found type `&{float}` found type `&{float}`
error: aborting due to 35 previous errors error: aborting due to 36 previous errors
For more information about this error, try `rustc --explain E0308`. For more information about this error, try `rustc --explain E0308`.

4
src/test/ui/impl-trait/impl-generic-mismatch-ab.stderr
View file

@ -5,7 +5,9 @@ LL | fn foo<A: Debug>(&self, a: &A, b: &impl Debug);
| -- type in trait | -- type in trait
... ...
LL | fn foo<B: Debug>(&self, a: &impl Debug, b: &B) { } LL | fn foo<B: Debug>(&self, a: &impl Debug, b: &B) { }
| ^^^^^^^^^^^ expected type parameter, found a different type parameter | - ^^^^^^^^^^^ expected type parameter `B`, found type parameter `impl Debug`
| |
| expected type parameter
| |
= note: expected type `fn(&(), &B, &impl Debug)` = note: expected type `fn(&(), &B, &impl Debug)`
found type `fn(&(), &impl Debug, &B)` found type `fn(&(), &impl Debug, &B)`

6
src/test/ui/impl-trait/universal-mismatched-type.stderr
View file

@ -2,9 +2,11 @@ error[E0308]: mismatched types
--> $DIR/universal-mismatched-type.rs:4:5 --> $DIR/universal-mismatched-type.rs:4:5
| |
LL | fn foo(x: impl Debug) -> String { LL | fn foo(x: impl Debug) -> String {
| ------ expected `std::string::String` because of return type | ---------- ------ expected `std::string::String` because of return type
| |
| this type parameter
LL | x LL | x
| ^ expected struct `std::string::String`, found type parameter | ^ expected struct `std::string::String`, found type parameter `impl Debug`
| |
= note: expected type `std::string::String` = note: expected type `std::string::String`
found type `impl Debug` found type `impl Debug`

11
src/test/ui/impl-trait/universal-two-impl-traits.stderr
View file

@ -1,11 +1,16 @@
error[E0308]: mismatched types error[E0308]: mismatched types
--> $DIR/universal-two-impl-traits.rs:5:9 --> $DIR/universal-two-impl-traits.rs:5:9
| |
LL | fn foo(x: impl Debug, y: impl Debug) -> String {
| ---------- ---------- found type parameter
| |
| expected type parameter
LL | let mut a = x;
LL | a = y; LL | a = y;
| ^ expected type parameter, found a different type parameter | ^ expected type parameter `impl Debug`, found a different type parameter `impl Debug`
| |
= note: expected type `impl Debug` (type parameter) = note: expected type `impl Debug` (type parameter `impl Debug`)
found type `impl Debug` (type parameter) found type `impl Debug` (type parameter `impl Debug`)
= note: a type parameter was expected, but a different one was found; you might be missing a type parameter or trait bound = note: a type parameter was expected, but a different one was found; you might be missing a type parameter or trait bound
= note: for more information, visit https://doc.rust-lang.org/book/ch10-02-traits.html#traits-as-parameters = note: for more information, visit https://doc.rust-lang.org/book/ch10-02-traits.html#traits-as-parameters

2
src/test/ui/imports/import-prefix-macro-1.stderr
View file

@ -2,7 +2,7 @@ error: expected one of `::`, `;`, or `as`, found `{`
--> $DIR/import-prefix-macro-1.rs:11:27 --> $DIR/import-prefix-macro-1.rs:11:27
| |
LL | ($p: path) => (use $p {S, Z}); LL | ($p: path) => (use $p {S, Z});
| ^ expected one of `::`, `;`, or `as` here | ^^^^^^ expected one of `::`, `;`, or `as` here
... ...
LL | import! { a::b::c } LL | import! { a::b::c }
| ------------------- in this macro invocation | ------------------- in this macro invocation

4
src/test/ui/issues/issue-13853.stderr
View file

@ -2,10 +2,10 @@ error[E0308]: mismatched types
--> $DIR/issue-13853.rs:14:9 --> $DIR/issue-13853.rs:14:9
| |
LL | fn nodes<'a, I: Iterator<Item=&'a N>>(&self) -> I LL | fn nodes<'a, I: Iterator<Item=&'a N>>(&self) -> I
| - expected `I` because of return type | - this type parameter - expected `I` because of return type
... ...
LL | self.iter() LL | self.iter()
| ^^^^^^^^^^^ expected type parameter, found struct `std::slice::Iter` | ^^^^^^^^^^^ expected type parameter `I`, found struct `std::slice::Iter`
| |
= note: expected type `I` = note: expected type `I`
found type `std::slice::Iter<'_, N>` found type `std::slice::Iter<'_, N>`

13
src/test/ui/issues/issue-20225.stderr
View file

@ -1,8 +1,10 @@
error[E0053]: method `call` has an incompatible type for trait error[E0053]: method `call` has an incompatible type for trait
--> $DIR/issue-20225.rs:6:3 --> $DIR/issue-20225.rs:6:3
| |
LL | impl<'a, T> Fn<(&'a T,)> for Foo {
| - this type parameter
LL | extern "rust-call" fn call(&self, (_,): (T,)) {} LL | extern "rust-call" fn call(&self, (_,): (T,)) {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected reference, found type parameter | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected reference, found type parameter `T`
| |
= note: expected type `extern "rust-call" fn(&Foo, (&'a T,))` = note: expected type `extern "rust-call" fn(&Foo, (&'a T,))`
found type `extern "rust-call" fn(&Foo, (T,))` found type `extern "rust-call" fn(&Foo, (T,))`
@ -12,8 +14,10 @@ LL | extern "rust-call" fn call(&self, (_,): (T,)) {}
error[E0053]: method `call_mut` has an incompatible type for trait error[E0053]: method `call_mut` has an incompatible type for trait
--> $DIR/issue-20225.rs:12:3 --> $DIR/issue-20225.rs:12:3
| |
LL | impl<'a, T> FnMut<(&'a T,)> for Foo {
| - this type parameter
LL | extern "rust-call" fn call_mut(&mut self, (_,): (T,)) {} LL | extern "rust-call" fn call_mut(&mut self, (_,): (T,)) {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected reference, found type parameter | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected reference, found type parameter `T`
| |
= note: expected type `extern "rust-call" fn(&mut Foo, (&'a T,))` = note: expected type `extern "rust-call" fn(&mut Foo, (&'a T,))`
found type `extern "rust-call" fn(&mut Foo, (T,))` found type `extern "rust-call" fn(&mut Foo, (T,))`
@ -23,8 +27,11 @@ LL | extern "rust-call" fn call_mut(&mut self, (_,): (T,)) {}
error[E0053]: method `call_once` has an incompatible type for trait error[E0053]: method `call_once` has an incompatible type for trait
--> $DIR/issue-20225.rs:20:3 --> $DIR/issue-20225.rs:20:3
| |
LL | impl<'a, T> FnOnce<(&'a T,)> for Foo {
| - this type parameter
...
LL | extern "rust-call" fn call_once(self, (_,): (T,)) {} LL | extern "rust-call" fn call_once(self, (_,): (T,)) {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected reference, found type parameter | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected reference, found type parameter `T`
| |
= note: expected type `extern "rust-call" fn(Foo, (&'a T,))` = note: expected type `extern "rust-call" fn(Foo, (&'a T,))`
found type `extern "rust-call" fn(Foo, (T,))` found type `extern "rust-call" fn(Foo, (T,))`

2
src/test/ui/issues/issue-24204.stderr
View file

@ -5,7 +5,7 @@ LL | trait Trait: Sized {
| ------------------ required by `Trait` | ------------------ required by `Trait`
... ...
LL | fn test<T: Trait<B=i32>>(b: i32) -> T where T::A: MultiDispatch<i32> { T::new(b) } LL | fn test<T: Trait<B=i32>>(b: i32) -> T where T::A: MultiDispatch<i32> { T::new(b) }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected type parameter, found associated type | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected type parameter `T`, found associated type
| |
= note: expected type `T` = note: expected type `T`
found type `<<T as Trait>::A as MultiDispatch<i32>>::O` found type `<<T as Trait>::A as MultiDispatch<i32>>::O`

2
src/test/ui/issues/issue-2951.rs
View file

@ -4,7 +4,7 @@ fn foo<T, U>(x: T, y: U) {
//~^ ERROR mismatched types //~^ ERROR mismatched types
//~| expected type `T` //~| expected type `T`
//~| found type `U` //~| found type `U`
//~| expected type parameter, found a different type parameter //~| expected type parameter `T`, found type parameter `U`
} }
fn main() { fn main() {

7
src/test/ui/issues/issue-2951.stderr
View file

@ -1,8 +1,13 @@
error[E0308]: mismatched types error[E0308]: mismatched types
--> $DIR/issue-2951.rs:3:10 --> $DIR/issue-2951.rs:3:10
| |
LL | fn foo<T, U>(x: T, y: U) {
| - - found type parameter
| |
| expected type parameter
LL | let mut xx = x;
LL | xx = y; LL | xx = y;
| ^ expected type parameter, found a different type parameter | ^ expected type parameter `T`, found type parameter `U`
| |
= note: expected type `T` = note: expected type `T`
found type `U` found type `U`

2
src/test/ui/issues/issue-39848.stderr
View file

@ -2,7 +2,7 @@ error: expected `{`, found `foo`
--> $DIR/issue-39848.rs:8:19 --> $DIR/issue-39848.rs:8:19
| |
LL | if $tgt.has_$field() {} LL | if $tgt.has_$field() {}
| -- - help: try placing this code inside a block: `{ ) }` | -- -- help: try placing this code inside a block: `{ () }`
| | | |
| this `if` statement has a condition, but no block | this `if` statement has a condition, but no block
... ...

7
src/test/ui/mismatched_types/issue-35030.stderr
View file

@ -1,10 +1,13 @@
error[E0308]: mismatched types error[E0308]: mismatched types
--> $DIR/issue-35030.rs:9:14 --> $DIR/issue-35030.rs:9:14
| |
LL | impl<bool> Parser<bool> for bool {
| ---- this type parameter
LL | fn parse(text: &str) -> Option<bool> {
LL | Some(true) LL | Some(true)
| ^^^^ expected type parameter, found bool | ^^^^ expected type parameter `bool`, found bool
| |
= note: expected type `bool` (type parameter) = note: expected type `bool` (type parameter `bool`)
found type `bool` (bool) found type `bool` (bool)
= help: type parameters must be constrained to match other types = help: type parameters must be constrained to match other types
= note: for more information, visit https://doc.rust-lang.org/book/ch10-02-traits.html#traits-as-parameters = note: for more information, visit https://doc.rust-lang.org/book/ch10-02-traits.html#traits-as-parameters

4
src/test/ui/nll/closure-requirements/escape-argument-callee.stderr
View file

@ -4,7 +4,7 @@ note: No external requirements
LL | let mut closure = expect_sig(|p, y| *p = y); LL | let mut closure = expect_sig(|p, y| *p = y);
| ^^^^^^^^^^^^^ | ^^^^^^^^^^^^^
| |
= note: defining type: DefId(0:13 ~ escape_argument_callee[317d]::test[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:4 ~ escape_argument_callee[317d]::test[0]::{{closure}}[0]) with closure substs [
i16, i16,
for<'r, 's, 't0> extern "rust-call" fn((&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) mut &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) i32, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't0)) i32)), for<'r, 's, 't0> extern "rust-call" fn((&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) mut &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) i32, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't0)) i32)),
] ]
@ -30,7 +30,7 @@ LL | | deref(p);
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:12 ~ escape_argument_callee[317d]::test[0]) with substs [] = note: defining type: DefId(0:3 ~ escape_argument_callee[317d]::test[0]) with substs []
error: aborting due to previous error error: aborting due to previous error

4
src/test/ui/nll/closure-requirements/escape-argument.stderr
View file

@ -4,7 +4,7 @@ note: No external requirements
LL | let mut closure = expect_sig(|p, y| *p = y); LL | let mut closure = expect_sig(|p, y| *p = y);
| ^^^^^^^^^^^^^ | ^^^^^^^^^^^^^
| |
= note: defining type: DefId(0:13 ~ escape_argument[317d]::test[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:4 ~ escape_argument[317d]::test[0]::{{closure}}[0]) with closure substs [
i16, i16,
for<'r, 's> extern "rust-call" fn((&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) mut &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) i32, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) i32)), for<'r, 's> extern "rust-call" fn((&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) mut &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) i32, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) i32)),
] ]
@ -21,7 +21,7 @@ LL | | deref(p);
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:12 ~ escape_argument[317d]::test[0]) with substs [] = note: defining type: DefId(0:3 ~ escape_argument[317d]::test[0]) with substs []
error[E0597]: `y` does not live long enough error[E0597]: `y` does not live long enough
--> $DIR/escape-argument.rs:27:25 --> $DIR/escape-argument.rs:27:25

6
src/test/ui/nll/closure-requirements/escape-upvar-nested.stderr
View file

@ -4,7 +4,7 @@ note: External requirements
LL | let mut closure1 = || p = &y; LL | let mut closure1 = || p = &y;
| ^^^^^^^^^ | ^^^^^^^^^
| |
= note: defining type: DefId(0:14 ~ escape_upvar_nested[317d]::test[0]::{{closure}}[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:5 ~ escape_upvar_nested[317d]::test[0]::{{closure}}[0]::{{closure}}[0]) with closure substs [
i16, i16,
extern "rust-call" fn(()), extern "rust-call" fn(()),
&'_#1r i32, &'_#1r i32,
@ -23,7 +23,7 @@ LL | | closure1();
LL | | }; LL | | };
| |_________^ | |_________^
| |
= note: defining type: DefId(0:13 ~ escape_upvar_nested[317d]::test[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:4 ~ escape_upvar_nested[317d]::test[0]::{{closure}}[0]) with closure substs [
i16, i16,
extern "rust-call" fn(()), extern "rust-call" fn(()),
&'_#1r i32, &'_#1r i32,
@ -44,7 +44,7 @@ LL | | deref(p);
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:12 ~ escape_upvar_nested[317d]::test[0]) with substs [] = note: defining type: DefId(0:3 ~ escape_upvar_nested[317d]::test[0]) with substs []
error[E0597]: `y` does not live long enough error[E0597]: `y` does not live long enough
--> $DIR/escape-upvar-nested.rs:21:40 --> $DIR/escape-upvar-nested.rs:21:40

4
src/test/ui/nll/closure-requirements/escape-upvar-ref.stderr
View file

@ -4,7 +4,7 @@ note: External requirements
LL | let mut closure = || p = &y; LL | let mut closure = || p = &y;
| ^^^^^^^^^ | ^^^^^^^^^
| |
= note: defining type: DefId(0:13 ~ escape_upvar_ref[317d]::test[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:4 ~ escape_upvar_ref[317d]::test[0]::{{closure}}[0]) with closure substs [
i16, i16,
extern "rust-call" fn(()), extern "rust-call" fn(()),
&'_#1r i32, &'_#1r i32,
@ -25,7 +25,7 @@ LL | | deref(p);
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:12 ~ escape_upvar_ref[317d]::test[0]) with substs [] = note: defining type: DefId(0:3 ~ escape_upvar_ref[317d]::test[0]) with substs []
error[E0597]: `y` does not live long enough error[E0597]: `y` does not live long enough
--> $DIR/escape-upvar-ref.rs:23:35 --> $DIR/escape-upvar-ref.rs:23:35

4
src/test/ui/nll/closure-requirements/propagate-approximated-fail-no-postdom.stderr
View file

@ -8,7 +8,7 @@ LL | | demand_y(x, y, p)
LL | | }, LL | | },
| |_________^ | |_________^
| |
= note: defining type: DefId(0:27 ~ propagate_approximated_fail_no_postdom[317d]::supply[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:18 ~ propagate_approximated_fail_no_postdom[317d]::supply[0]::{{closure}}[0]) with closure substs [
i16, i16,
for<'r, 's> extern "rust-call" fn((std::cell::Cell<&'_#1r &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) u32>, std::cell::Cell<&'_#2r &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) u32>, std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) &'_#3r u32>, std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) u32>, std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) u32>)), for<'r, 's> extern "rust-call" fn((std::cell::Cell<&'_#1r &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) u32>, std::cell::Cell<&'_#2r &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) u32>, std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) &'_#3r u32>, std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) u32>, std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) u32>)),
] ]
@ -39,7 +39,7 @@ LL | | );
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:23 ~ propagate_approximated_fail_no_postdom[317d]::supply[0]) with substs [] = note: defining type: DefId(0:14 ~ propagate_approximated_fail_no_postdom[317d]::supply[0]) with substs []
error: aborting due to previous error error: aborting due to previous error

4
src/test/ui/nll/closure-requirements/propagate-approximated-ref.stderr
View file

@ -9,7 +9,7 @@ LL | |
LL | | }); LL | | });
| |_____^ | |_____^
| |
= note: defining type: DefId(0:25 ~ propagate_approximated_ref[317d]::supply[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:16 ~ propagate_approximated_ref[317d]::supply[0]::{{closure}}[0]) with closure substs [
i16, i16,
for<'r, 's, 't0, 't1, 't2, 't3> extern "rust-call" fn((&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) std::cell::Cell<&'_#1r &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) u32>, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't0)) std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't1)) &'_#2r u32>, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't2)) std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) u32>, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't3)) std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't1)) u32>)), for<'r, 's, 't0, 't1, 't2, 't3> extern "rust-call" fn((&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) std::cell::Cell<&'_#1r &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) u32>, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't0)) std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't1)) &'_#2r u32>, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't2)) std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) u32>, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't3)) std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't1)) u32>)),
] ]
@ -30,7 +30,7 @@ LL | | });
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:22 ~ propagate_approximated_ref[317d]::supply[0]) with substs [] = note: defining type: DefId(0:13 ~ propagate_approximated_ref[317d]::supply[0]) with substs []
error: lifetime may not live long enough error: lifetime may not live long enough
--> $DIR/propagate-approximated-ref.rs:45:9 --> $DIR/propagate-approximated-ref.rs:45:9

8
src/test/ui/nll/closure-requirements/propagate-approximated-shorter-to-static-comparing-against-free.stderr
View file

@ -8,7 +8,7 @@ LL | |
LL | | }) LL | | })
| |_____^ | |_____^
| |
= note: defining type: DefId(0:18 ~ propagate_approximated_shorter_to_static_comparing_against_free[317d]::case1[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:9 ~ propagate_approximated_shorter_to_static_comparing_against_free[317d]::case1[0]::{{closure}}[0]) with closure substs [
i32, i32,
for<'r> extern "rust-call" fn((std::cell::Cell<&'_#1r u32>, std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) u32>)), for<'r> extern "rust-call" fn((std::cell::Cell<&'_#1r u32>, std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) u32>)),
] ]
@ -35,7 +35,7 @@ LL | | })
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:17 ~ propagate_approximated_shorter_to_static_comparing_against_free[317d]::case1[0]) with substs [] = note: defining type: DefId(0:8 ~ propagate_approximated_shorter_to_static_comparing_against_free[317d]::case1[0]) with substs []
note: External requirements note: External requirements
--> $DIR/propagate-approximated-shorter-to-static-comparing-against-free.rs:35:15 --> $DIR/propagate-approximated-shorter-to-static-comparing-against-free.rs:35:15
@ -46,7 +46,7 @@ LL | | cell_x.set(cell_a.get()); // forces 'a: 'x, implies 'a = 'static
LL | | }) LL | | })
| |_____^ | |_____^
| |
= note: defining type: DefId(0:20 ~ propagate_approximated_shorter_to_static_comparing_against_free[317d]::case2[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:11 ~ propagate_approximated_shorter_to_static_comparing_against_free[317d]::case2[0]::{{closure}}[0]) with closure substs [
i32, i32,
for<'r> extern "rust-call" fn((std::cell::Cell<&'_#1r u32>, std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) u32>)), for<'r> extern "rust-call" fn((std::cell::Cell<&'_#1r u32>, std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) u32>)),
] ]
@ -65,7 +65,7 @@ LL | | })
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:19 ~ propagate_approximated_shorter_to_static_comparing_against_free[317d]::case2[0]) with substs [] = note: defining type: DefId(0:10 ~ propagate_approximated_shorter_to_static_comparing_against_free[317d]::case2[0]) with substs []
error[E0597]: `a` does not live long enough error[E0597]: `a` does not live long enough
--> $DIR/propagate-approximated-shorter-to-static-comparing-against-free.rs:30:26 --> $DIR/propagate-approximated-shorter-to-static-comparing-against-free.rs:30:26

4
src/test/ui/nll/closure-requirements/propagate-approximated-shorter-to-static-no-bound.stderr
View file

@ -10,7 +10,7 @@ LL | | demand_y(x, y, x.get())
LL | | }); LL | | });
| |_____^ | |_____^
| |
= note: defining type: DefId(0:25 ~ propagate_approximated_shorter_to_static_no_bound[317d]::supply[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:16 ~ propagate_approximated_shorter_to_static_no_bound[317d]::supply[0]::{{closure}}[0]) with closure substs [
i16, i16,
for<'r, 's, 't0, 't1, 't2> extern "rust-call" fn((&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) std::cell::Cell<&'_#1r &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) u32>, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't0)) std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) u32>, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't1)) std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't2)) u32>)), for<'r, 's, 't0, 't1, 't2> extern "rust-call" fn((&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) std::cell::Cell<&'_#1r &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) u32>, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't0)) std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) u32>, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't1)) std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't2)) u32>)),
] ]
@ -31,7 +31,7 @@ LL | | });
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:22 ~ propagate_approximated_shorter_to_static_no_bound[317d]::supply[0]) with substs [] = note: defining type: DefId(0:13 ~ propagate_approximated_shorter_to_static_no_bound[317d]::supply[0]) with substs []
error[E0521]: borrowed data escapes outside of function error[E0521]: borrowed data escapes outside of function
--> $DIR/propagate-approximated-shorter-to-static-no-bound.rs:32:5 --> $DIR/propagate-approximated-shorter-to-static-no-bound.rs:32:5

4
src/test/ui/nll/closure-requirements/propagate-approximated-shorter-to-static-wrong-bound.stderr
View file

@ -10,7 +10,7 @@ LL | | demand_y(x, y, x.get())
LL | | }); LL | | });
| |_____^ | |_____^
| |
= note: defining type: DefId(0:25 ~ propagate_approximated_shorter_to_static_wrong_bound[317d]::supply[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:16 ~ propagate_approximated_shorter_to_static_wrong_bound[317d]::supply[0]::{{closure}}[0]) with closure substs [
i16, i16,
for<'r, 's, 't0, 't1, 't2, 't3> extern "rust-call" fn((&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) std::cell::Cell<&'_#1r &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) u32>, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't0)) std::cell::Cell<&'_#2r &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't1)) u32>, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't2)) std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) u32>, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't3)) std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't1)) u32>)), for<'r, 's, 't0, 't1, 't2, 't3> extern "rust-call" fn((&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) std::cell::Cell<&'_#1r &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) u32>, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't0)) std::cell::Cell<&'_#2r &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't1)) u32>, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't2)) std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) u32>, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't3)) std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't1)) u32>)),
] ]
@ -31,7 +31,7 @@ LL | | });
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:22 ~ propagate_approximated_shorter_to_static_wrong_bound[317d]::supply[0]) with substs [] = note: defining type: DefId(0:13 ~ propagate_approximated_shorter_to_static_wrong_bound[317d]::supply[0]) with substs []
error[E0521]: borrowed data escapes outside of function error[E0521]: borrowed data escapes outside of function
--> $DIR/propagate-approximated-shorter-to-static-wrong-bound.rs:35:5 --> $DIR/propagate-approximated-shorter-to-static-wrong-bound.rs:35:5

4
src/test/ui/nll/closure-requirements/propagate-approximated-val.stderr
View file

@ -9,7 +9,7 @@ LL | |
LL | | }); LL | | });
| |_____^ | |_____^
| |
= note: defining type: DefId(0:25 ~ propagate_approximated_val[317d]::test[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:16 ~ propagate_approximated_val[317d]::test[0]::{{closure}}[0]) with closure substs [
i16, i16,
for<'r, 's> extern "rust-call" fn((std::cell::Cell<&'_#1r &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) u32>, std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) &'_#2r u32>, std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) u32>, std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) u32>)), for<'r, 's> extern "rust-call" fn((std::cell::Cell<&'_#1r &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) u32>, std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) &'_#2r u32>, std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) u32>, std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) u32>)),
] ]
@ -30,7 +30,7 @@ LL | | });
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:22 ~ propagate_approximated_val[317d]::test[0]) with substs [] = note: defining type: DefId(0:13 ~ propagate_approximated_val[317d]::test[0]) with substs []
error: lifetime may not live long enough error: lifetime may not live long enough
--> $DIR/propagate-approximated-val.rs:38:9 --> $DIR/propagate-approximated-val.rs:38:9

4
src/test/ui/nll/closure-requirements/propagate-despite-same-free-region.stderr
View file

@ -8,7 +8,7 @@ LL | | demand_y(x, y, p)
LL | | }, LL | | },
| |_________^ | |_________^
| |
= note: defining type: DefId(0:23 ~ propagate_despite_same_free_region[317d]::supply[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:14 ~ propagate_despite_same_free_region[317d]::supply[0]::{{closure}}[0]) with closure substs [
i16, i16,
for<'r, 's> extern "rust-call" fn((std::cell::Cell<&'_#1r &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) u32>, std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) &'_#2r u32>, std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) u32>, std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) u32>)), for<'r, 's> extern "rust-call" fn((std::cell::Cell<&'_#1r &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) u32>, std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) &'_#2r u32>, std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) u32>, std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) u32>)),
] ]
@ -28,5 +28,5 @@ LL | | );
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:21 ~ propagate_despite_same_free_region[317d]::supply[0]) with substs [] = note: defining type: DefId(0:12 ~ propagate_despite_same_free_region[317d]::supply[0]) with substs []

4
src/test/ui/nll/closure-requirements/propagate-fail-to-approximate-longer-no-bounds.stderr
View file

@ -9,7 +9,7 @@ LL | |
LL | | }); LL | | });
| |_____^ | |_____^
| |
= note: defining type: DefId(0:25 ~ propagate_fail_to_approximate_longer_no_bounds[317d]::supply[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:16 ~ propagate_fail_to_approximate_longer_no_bounds[317d]::supply[0]::{{closure}}[0]) with closure substs [
i16, i16,
for<'r, 's, 't0, 't1, 't2> extern "rust-call" fn((&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) &'_#1r u32>, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't0)) std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't1)) u32>, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't2)) std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) u32>)), for<'r, 's, 't0, 't1, 't2> extern "rust-call" fn((&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) &'_#1r u32>, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't0)) std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't1)) u32>, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't2)) std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) u32>)),
] ]
@ -39,7 +39,7 @@ LL | | });
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:22 ~ propagate_fail_to_approximate_longer_no_bounds[317d]::supply[0]) with substs [] = note: defining type: DefId(0:13 ~ propagate_fail_to_approximate_longer_no_bounds[317d]::supply[0]) with substs []
error: aborting due to previous error error: aborting due to previous error

4
src/test/ui/nll/closure-requirements/propagate-fail-to-approximate-longer-wrong-bounds.stderr
View file

@ -9,7 +9,7 @@ LL | |
LL | | }); LL | | });
| |_____^ | |_____^
| |
= note: defining type: DefId(0:25 ~ propagate_fail_to_approximate_longer_wrong_bounds[317d]::supply[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:16 ~ propagate_fail_to_approximate_longer_wrong_bounds[317d]::supply[0]::{{closure}}[0]) with closure substs [
i16, i16,
for<'r, 's, 't0, 't1, 't2, 't3> extern "rust-call" fn((&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) &'_#1r u32>, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't0)) std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't1)) &'_#2r u32>, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't2)) std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) u32>, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't3)) std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't1)) u32>)), for<'r, 's, 't0, 't1, 't2, 't3> extern "rust-call" fn((&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) &'_#1r u32>, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't0)) std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't1)) &'_#2r u32>, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't2)) std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) u32>, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't3)) std::cell::Cell<&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 't1)) u32>)),
] ]
@ -39,7 +39,7 @@ LL | | });
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:22 ~ propagate_fail_to_approximate_longer_wrong_bounds[317d]::supply[0]) with substs [] = note: defining type: DefId(0:13 ~ propagate_fail_to_approximate_longer_wrong_bounds[317d]::supply[0]) with substs []
error: aborting due to previous error error: aborting due to previous error

4
src/test/ui/nll/closure-requirements/propagate-from-trait-match.stderr
View file

@ -11,7 +11,7 @@ LL | | require(value);
LL | | }); LL | | });
| |_____^ | |_____^
| |
= note: defining type: DefId(0:23 ~ propagate_from_trait_match[317d]::supply[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:14 ~ propagate_from_trait_match[317d]::supply[0]::{{closure}}[0]) with closure substs [
'_#1r, '_#1r,
T, T,
i32, i32,
@ -32,7 +32,7 @@ LL | | });
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:20 ~ propagate_from_trait_match[317d]::supply[0]) with substs [ = note: defining type: DefId(0:11 ~ propagate_from_trait_match[317d]::supply[0]) with substs [
'_#1r, '_#1r,
T, T,
] ]

4
src/test/ui/nll/closure-requirements/return-wrong-bound-region.stderr
View file

@ -4,7 +4,7 @@ note: No external requirements
LL | expect_sig(|a, b| b); // ought to return `a` LL | expect_sig(|a, b| b); // ought to return `a`
| ^^^^^^^^ | ^^^^^^^^
| |
= note: defining type: DefId(0:13 ~ return_wrong_bound_region[317d]::test[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:4 ~ return_wrong_bound_region[317d]::test[0]::{{closure}}[0]) with closure substs [
i16, i16,
for<'r, 's> extern "rust-call" fn((&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) i32, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) i32)) -> &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) i32, for<'r, 's> extern "rust-call" fn((&ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) i32, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) i32)) -> &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) i32,
] ]
@ -27,7 +27,7 @@ LL | |
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:12 ~ return_wrong_bound_region[317d]::test[0]) with substs [] = note: defining type: DefId(0:3 ~ return_wrong_bound_region[317d]::test[0]) with substs []
error: aborting due to previous error error: aborting due to previous error

16
src/test/ui/nll/ty-outlives/projection-no-regions-closure.stderr
View file

@ -4,7 +4,7 @@ note: External requirements
LL | with_signature(x, |mut y| Box::new(y.next())) LL | with_signature(x, |mut y| Box::new(y.next()))
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= note: defining type: DefId(0:22 ~ projection_no_regions_closure[317d]::no_region[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:13 ~ projection_no_regions_closure[317d]::no_region[0]::{{closure}}[0]) with closure substs [
'_#1r, '_#1r,
T, T,
i32, i32,
@ -25,7 +25,7 @@ LL | |
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:19 ~ projection_no_regions_closure[317d]::no_region[0]) with substs [ = note: defining type: DefId(0:10 ~ projection_no_regions_closure[317d]::no_region[0]) with substs [
'_#1r, '_#1r,
T, T,
] ]
@ -44,7 +44,7 @@ note: External requirements
LL | with_signature(x, |mut y| Box::new(y.next())) LL | with_signature(x, |mut y| Box::new(y.next()))
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= note: defining type: DefId(0:26 ~ projection_no_regions_closure[317d]::correct_region[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:17 ~ projection_no_regions_closure[317d]::correct_region[0]::{{closure}}[0]) with closure substs [
'_#1r, '_#1r,
T, T,
i32, i32,
@ -64,7 +64,7 @@ LL | | with_signature(x, |mut y| Box::new(y.next()))
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:23 ~ projection_no_regions_closure[317d]::correct_region[0]) with substs [ = note: defining type: DefId(0:14 ~ projection_no_regions_closure[317d]::correct_region[0]) with substs [
'_#1r, '_#1r,
T, T,
] ]
@ -75,7 +75,7 @@ note: External requirements
LL | with_signature(x, |mut y| Box::new(y.next())) LL | with_signature(x, |mut y| Box::new(y.next()))
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= note: defining type: DefId(0:31 ~ projection_no_regions_closure[317d]::wrong_region[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:22 ~ projection_no_regions_closure[317d]::wrong_region[0]::{{closure}}[0]) with closure substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
T, T,
@ -97,7 +97,7 @@ LL | |
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:27 ~ projection_no_regions_closure[317d]::wrong_region[0]) with substs [ = note: defining type: DefId(0:18 ~ projection_no_regions_closure[317d]::wrong_region[0]) with substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
T, T,
@ -117,7 +117,7 @@ note: External requirements
LL | with_signature(x, |mut y| Box::new(y.next())) LL | with_signature(x, |mut y| Box::new(y.next()))
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= note: defining type: DefId(0:36 ~ projection_no_regions_closure[317d]::outlives_region[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:27 ~ projection_no_regions_closure[317d]::outlives_region[0]::{{closure}}[0]) with closure substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
T, T,
@ -139,7 +139,7 @@ LL | | with_signature(x, |mut y| Box::new(y.next()))
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:32 ~ projection_no_regions_closure[317d]::outlives_region[0]) with substs [ = note: defining type: DefId(0:23 ~ projection_no_regions_closure[317d]::outlives_region[0]) with substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
T, T,

18
src/test/ui/nll/ty-outlives/projection-one-region-closure.stderr
View file

@ -4,7 +4,7 @@ note: External requirements
LL | with_signature(cell, t, |cell, t| require(cell, t)); LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= note: defining type: DefId(0:28 ~ projection_one_region_closure[317d]::no_relationships_late[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:19 ~ projection_one_region_closure[317d]::no_relationships_late[0]::{{closure}}[0]) with closure substs [
'_#1r, '_#1r,
T, T,
i32, i32,
@ -27,7 +27,7 @@ LL | |
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:24 ~ projection_one_region_closure[317d]::no_relationships_late[0]) with substs [ = note: defining type: DefId(0:15 ~ projection_one_region_closure[317d]::no_relationships_late[0]) with substs [
'_#1r, '_#1r,
T, T,
] ]
@ -38,7 +38,7 @@ error[E0309]: the parameter type `T` may not live long enough
LL | with_signature(cell, t, |cell, t| require(cell, t)); LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= help: consider adding an explicit lifetime bound `T: ReFree(DefId(0:24 ~ projection_one_region_closure[317d]::no_relationships_late[0]), BrNamed(crate0:DefIndex(25), 'a))`... = help: consider adding an explicit lifetime bound `T: ReFree(DefId(0:15 ~ projection_one_region_closure[317d]::no_relationships_late[0]), BrNamed(crate0:DefIndex(16), 'a))`...
error: lifetime may not live long enough error: lifetime may not live long enough
--> $DIR/projection-one-region-closure.rs:45:39 --> $DIR/projection-one-region-closure.rs:45:39
@ -57,7 +57,7 @@ note: External requirements
LL | with_signature(cell, t, |cell, t| require(cell, t)); LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= note: defining type: DefId(0:33 ~ projection_one_region_closure[317d]::no_relationships_early[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:24 ~ projection_one_region_closure[317d]::no_relationships_early[0]::{{closure}}[0]) with closure substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
T, T,
@ -80,7 +80,7 @@ LL | |
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:29 ~ projection_one_region_closure[317d]::no_relationships_early[0]) with substs [ = note: defining type: DefId(0:20 ~ projection_one_region_closure[317d]::no_relationships_early[0]) with substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
T, T,
@ -111,7 +111,7 @@ note: External requirements
LL | with_signature(cell, t, |cell, t| require(cell, t)); LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= note: defining type: DefId(0:38 ~ projection_one_region_closure[317d]::projection_outlives[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:29 ~ projection_one_region_closure[317d]::projection_outlives[0]::{{closure}}[0]) with closure substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
T, T,
@ -133,7 +133,7 @@ LL | | with_signature(cell, t, |cell, t| require(cell, t));
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:34 ~ projection_one_region_closure[317d]::projection_outlives[0]) with substs [ = note: defining type: DefId(0:25 ~ projection_one_region_closure[317d]::projection_outlives[0]) with substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
T, T,
@ -145,7 +145,7 @@ note: External requirements
LL | with_signature(cell, t, |cell, t| require(cell, t)); LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= note: defining type: DefId(0:43 ~ projection_one_region_closure[317d]::elements_outlive[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:34 ~ projection_one_region_closure[317d]::elements_outlive[0]::{{closure}}[0]) with closure substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
T, T,
@ -168,7 +168,7 @@ LL | | with_signature(cell, t, |cell, t| require(cell, t));
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:39 ~ projection_one_region_closure[317d]::elements_outlive[0]) with substs [ = note: defining type: DefId(0:30 ~ projection_one_region_closure[317d]::elements_outlive[0]) with substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
T, T,

20
src/test/ui/nll/ty-outlives/projection-one-region-trait-bound-closure.stderr
View file

@ -4,7 +4,7 @@ note: External requirements
LL | with_signature(cell, t, |cell, t| require(cell, t)); LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= note: defining type: DefId(0:28 ~ projection_one_region_trait_bound_closure[317d]::no_relationships_late[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:19 ~ projection_one_region_trait_bound_closure[317d]::no_relationships_late[0]::{{closure}}[0]) with closure substs [
'_#1r, '_#1r,
T, T,
i32, i32,
@ -26,7 +26,7 @@ LL | |
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:24 ~ projection_one_region_trait_bound_closure[317d]::no_relationships_late[0]) with substs [ = note: defining type: DefId(0:15 ~ projection_one_region_trait_bound_closure[317d]::no_relationships_late[0]) with substs [
'_#1r, '_#1r,
T, T,
] ]
@ -48,7 +48,7 @@ note: External requirements
LL | with_signature(cell, t, |cell, t| require(cell, t)); LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= note: defining type: DefId(0:33 ~ projection_one_region_trait_bound_closure[317d]::no_relationships_early[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:24 ~ projection_one_region_trait_bound_closure[317d]::no_relationships_early[0]::{{closure}}[0]) with closure substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
T, T,
@ -70,7 +70,7 @@ LL | |
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:29 ~ projection_one_region_trait_bound_closure[317d]::no_relationships_early[0]) with substs [ = note: defining type: DefId(0:20 ~ projection_one_region_trait_bound_closure[317d]::no_relationships_early[0]) with substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
T, T,
@ -93,7 +93,7 @@ note: External requirements
LL | with_signature(cell, t, |cell, t| require(cell, t)); LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= note: defining type: DefId(0:38 ~ projection_one_region_trait_bound_closure[317d]::projection_outlives[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:29 ~ projection_one_region_trait_bound_closure[317d]::projection_outlives[0]::{{closure}}[0]) with closure substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
T, T,
@ -115,7 +115,7 @@ LL | | with_signature(cell, t, |cell, t| require(cell, t));
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:34 ~ projection_one_region_trait_bound_closure[317d]::projection_outlives[0]) with substs [ = note: defining type: DefId(0:25 ~ projection_one_region_trait_bound_closure[317d]::projection_outlives[0]) with substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
T, T,
@ -127,7 +127,7 @@ note: External requirements
LL | with_signature(cell, t, |cell, t| require(cell, t)); LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= note: defining type: DefId(0:43 ~ projection_one_region_trait_bound_closure[317d]::elements_outlive[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:34 ~ projection_one_region_trait_bound_closure[317d]::elements_outlive[0]::{{closure}}[0]) with closure substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
T, T,
@ -149,7 +149,7 @@ LL | | with_signature(cell, t, |cell, t| require(cell, t));
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:39 ~ projection_one_region_trait_bound_closure[317d]::elements_outlive[0]) with substs [ = note: defining type: DefId(0:30 ~ projection_one_region_trait_bound_closure[317d]::elements_outlive[0]) with substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
T, T,
@ -161,7 +161,7 @@ note: External requirements
LL | with_signature(cell, t, |cell, t| require(cell, t)); LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= note: defining type: DefId(0:47 ~ projection_one_region_trait_bound_closure[317d]::one_region[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:38 ~ projection_one_region_trait_bound_closure[317d]::one_region[0]::{{closure}}[0]) with closure substs [
'_#1r, '_#1r,
T, T,
i32, i32,
@ -182,7 +182,7 @@ LL | | with_signature(cell, t, |cell, t| require(cell, t));
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:44 ~ projection_one_region_trait_bound_closure[317d]::one_region[0]) with substs [ = note: defining type: DefId(0:35 ~ projection_one_region_trait_bound_closure[317d]::one_region[0]) with substs [
'_#1r, '_#1r,
T, T,
] ]

20
src/test/ui/nll/ty-outlives/projection-one-region-trait-bound-static-closure.stderr
View file

@ -4,7 +4,7 @@ note: No external requirements
LL | with_signature(cell, t, |cell, t| require(cell, t)); LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= note: defining type: DefId(0:28 ~ projection_one_region_trait_bound_static_closure[317d]::no_relationships_late[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:19 ~ projection_one_region_trait_bound_static_closure[317d]::no_relationships_late[0]::{{closure}}[0]) with closure substs [
'_#1r, '_#1r,
T, T,
i32, i32,
@ -23,7 +23,7 @@ LL | | with_signature(cell, t, |cell, t| require(cell, t));
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:24 ~ projection_one_region_trait_bound_static_closure[317d]::no_relationships_late[0]) with substs [ = note: defining type: DefId(0:15 ~ projection_one_region_trait_bound_static_closure[317d]::no_relationships_late[0]) with substs [
'_#1r, '_#1r,
T, T,
] ]
@ -34,7 +34,7 @@ note: No external requirements
LL | with_signature(cell, t, |cell, t| require(cell, t)); LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= note: defining type: DefId(0:33 ~ projection_one_region_trait_bound_static_closure[317d]::no_relationships_early[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:24 ~ projection_one_region_trait_bound_static_closure[317d]::no_relationships_early[0]::{{closure}}[0]) with closure substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
T, T,
@ -54,7 +54,7 @@ LL | | with_signature(cell, t, |cell, t| require(cell, t));
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:29 ~ projection_one_region_trait_bound_static_closure[317d]::no_relationships_early[0]) with substs [ = note: defining type: DefId(0:20 ~ projection_one_region_trait_bound_static_closure[317d]::no_relationships_early[0]) with substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
T, T,
@ -66,7 +66,7 @@ note: No external requirements
LL | with_signature(cell, t, |cell, t| require(cell, t)); LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= note: defining type: DefId(0:38 ~ projection_one_region_trait_bound_static_closure[317d]::projection_outlives[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:29 ~ projection_one_region_trait_bound_static_closure[317d]::projection_outlives[0]::{{closure}}[0]) with closure substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
T, T,
@ -86,7 +86,7 @@ LL | | with_signature(cell, t, |cell, t| require(cell, t));
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:34 ~ projection_one_region_trait_bound_static_closure[317d]::projection_outlives[0]) with substs [ = note: defining type: DefId(0:25 ~ projection_one_region_trait_bound_static_closure[317d]::projection_outlives[0]) with substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
T, T,
@ -98,7 +98,7 @@ note: No external requirements
LL | with_signature(cell, t, |cell, t| require(cell, t)); LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= note: defining type: DefId(0:43 ~ projection_one_region_trait_bound_static_closure[317d]::elements_outlive[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:34 ~ projection_one_region_trait_bound_static_closure[317d]::elements_outlive[0]::{{closure}}[0]) with closure substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
T, T,
@ -118,7 +118,7 @@ LL | | with_signature(cell, t, |cell, t| require(cell, t));
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:39 ~ projection_one_region_trait_bound_static_closure[317d]::elements_outlive[0]) with substs [ = note: defining type: DefId(0:30 ~ projection_one_region_trait_bound_static_closure[317d]::elements_outlive[0]) with substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
T, T,
@ -130,7 +130,7 @@ note: No external requirements
LL | with_signature(cell, t, |cell, t| require(cell, t)); LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= note: defining type: DefId(0:47 ~ projection_one_region_trait_bound_static_closure[317d]::one_region[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:38 ~ projection_one_region_trait_bound_static_closure[317d]::one_region[0]::{{closure}}[0]) with closure substs [
'_#1r, '_#1r,
T, T,
i32, i32,
@ -149,7 +149,7 @@ LL | | with_signature(cell, t, |cell, t| require(cell, t));
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:44 ~ projection_one_region_trait_bound_static_closure[317d]::one_region[0]) with substs [ = note: defining type: DefId(0:35 ~ projection_one_region_trait_bound_static_closure[317d]::one_region[0]) with substs [
'_#1r, '_#1r,
T, T,
] ]

34
src/test/ui/nll/ty-outlives/projection-two-region-trait-bound-closure.stderr
View file

@ -4,7 +4,7 @@ note: External requirements
LL | with_signature(cell, t, |cell, t| require(cell, t)); LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= note: defining type: DefId(0:31 ~ projection_two_region_trait_bound_closure[317d]::no_relationships_late[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:22 ~ projection_two_region_trait_bound_closure[317d]::no_relationships_late[0]::{{closure}}[0]) with closure substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
T, T,
@ -27,7 +27,7 @@ LL | |
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:26 ~ projection_two_region_trait_bound_closure[317d]::no_relationships_late[0]) with substs [ = note: defining type: DefId(0:17 ~ projection_two_region_trait_bound_closure[317d]::no_relationships_late[0]) with substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
T, T,
@ -39,7 +39,7 @@ error[E0309]: the associated type `<T as Anything<'_#5r, '_#6r>>::AssocType` may
LL | with_signature(cell, t, |cell, t| require(cell, t)); LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= help: consider adding an explicit lifetime bound `<T as Anything<'_#5r, '_#6r>>::AssocType: ReFree(DefId(0:26 ~ projection_two_region_trait_bound_closure[317d]::no_relationships_late[0]), BrNamed(crate0:DefIndex(27), 'a))`... = help: consider adding an explicit lifetime bound `<T as Anything<'_#5r, '_#6r>>::AssocType: ReFree(DefId(0:17 ~ projection_two_region_trait_bound_closure[317d]::no_relationships_late[0]), BrNamed(crate0:DefIndex(18), 'a))`...
note: External requirements note: External requirements
--> $DIR/projection-two-region-trait-bound-closure.rs:48:29 --> $DIR/projection-two-region-trait-bound-closure.rs:48:29
@ -47,7 +47,7 @@ note: External requirements
LL | with_signature(cell, t, |cell, t| require(cell, t)); LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= note: defining type: DefId(0:37 ~ projection_two_region_trait_bound_closure[317d]::no_relationships_early[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:28 ~ projection_two_region_trait_bound_closure[317d]::no_relationships_early[0]::{{closure}}[0]) with closure substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
'_#3r, '_#3r,
@ -70,7 +70,7 @@ LL | |
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:32 ~ projection_two_region_trait_bound_closure[317d]::no_relationships_early[0]) with substs [ = note: defining type: DefId(0:23 ~ projection_two_region_trait_bound_closure[317d]::no_relationships_early[0]) with substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
'_#3r, '_#3r,
@ -91,7 +91,7 @@ note: External requirements
LL | with_signature(cell, t, |cell, t| require(cell, t)); LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= note: defining type: DefId(0:43 ~ projection_two_region_trait_bound_closure[317d]::projection_outlives[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:34 ~ projection_two_region_trait_bound_closure[317d]::projection_outlives[0]::{{closure}}[0]) with closure substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
'_#3r, '_#3r,
@ -114,7 +114,7 @@ LL | | with_signature(cell, t, |cell, t| require(cell, t));
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:38 ~ projection_two_region_trait_bound_closure[317d]::projection_outlives[0]) with substs [ = note: defining type: DefId(0:29 ~ projection_two_region_trait_bound_closure[317d]::projection_outlives[0]) with substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
'_#3r, '_#3r,
@ -127,7 +127,7 @@ note: External requirements
LL | with_signature(cell, t, |cell, t| require(cell, t)); LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= note: defining type: DefId(0:49 ~ projection_two_region_trait_bound_closure[317d]::elements_outlive1[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:40 ~ projection_two_region_trait_bound_closure[317d]::elements_outlive1[0]::{{closure}}[0]) with closure substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
'_#3r, '_#3r,
@ -150,7 +150,7 @@ LL | | with_signature(cell, t, |cell, t| require(cell, t));
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:44 ~ projection_two_region_trait_bound_closure[317d]::elements_outlive1[0]) with substs [ = note: defining type: DefId(0:35 ~ projection_two_region_trait_bound_closure[317d]::elements_outlive1[0]) with substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
'_#3r, '_#3r,
@ -163,7 +163,7 @@ note: External requirements
LL | with_signature(cell, t, |cell, t| require(cell, t)); LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= note: defining type: DefId(0:55 ~ projection_two_region_trait_bound_closure[317d]::elements_outlive2[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:46 ~ projection_two_region_trait_bound_closure[317d]::elements_outlive2[0]::{{closure}}[0]) with closure substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
'_#3r, '_#3r,
@ -186,7 +186,7 @@ LL | | with_signature(cell, t, |cell, t| require(cell, t));
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:50 ~ projection_two_region_trait_bound_closure[317d]::elements_outlive2[0]) with substs [ = note: defining type: DefId(0:41 ~ projection_two_region_trait_bound_closure[317d]::elements_outlive2[0]) with substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
'_#3r, '_#3r,
@ -199,7 +199,7 @@ note: External requirements
LL | with_signature(cell, t, |cell, t| require(cell, t)); LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= note: defining type: DefId(0:60 ~ projection_two_region_trait_bound_closure[317d]::two_regions[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:51 ~ projection_two_region_trait_bound_closure[317d]::two_regions[0]::{{closure}}[0]) with closure substs [
'_#1r, '_#1r,
T, T,
i32, i32,
@ -221,7 +221,7 @@ LL | |
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:56 ~ projection_two_region_trait_bound_closure[317d]::two_regions[0]) with substs [ = note: defining type: DefId(0:47 ~ projection_two_region_trait_bound_closure[317d]::two_regions[0]) with substs [
'_#1r, '_#1r,
T, T,
] ]
@ -243,7 +243,7 @@ note: External requirements
LL | with_signature(cell, t, |cell, t| require(cell, t)); LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= note: defining type: DefId(0:65 ~ projection_two_region_trait_bound_closure[317d]::two_regions_outlive[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:56 ~ projection_two_region_trait_bound_closure[317d]::two_regions_outlive[0]::{{closure}}[0]) with closure substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
T, T,
@ -265,7 +265,7 @@ LL | | with_signature(cell, t, |cell, t| require(cell, t));
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:61 ~ projection_two_region_trait_bound_closure[317d]::two_regions_outlive[0]) with substs [ = note: defining type: DefId(0:52 ~ projection_two_region_trait_bound_closure[317d]::two_regions_outlive[0]) with substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
T, T,
@ -277,7 +277,7 @@ note: External requirements
LL | with_signature(cell, t, |cell, t| require(cell, t)); LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= note: defining type: DefId(0:69 ~ projection_two_region_trait_bound_closure[317d]::one_region[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:60 ~ projection_two_region_trait_bound_closure[317d]::one_region[0]::{{closure}}[0]) with closure substs [
'_#1r, '_#1r,
T, T,
i32, i32,
@ -298,7 +298,7 @@ LL | | with_signature(cell, t, |cell, t| require(cell, t));
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:66 ~ projection_two_region_trait_bound_closure[317d]::one_region[0]) with substs [ = note: defining type: DefId(0:57 ~ projection_two_region_trait_bound_closure[317d]::one_region[0]) with substs [
'_#1r, '_#1r,
T, T,
] ]

10
src/test/ui/nll/ty-outlives/ty-param-closure-approximate-lower-bound.stderr
View file

@ -4,7 +4,7 @@ note: External requirements
LL | twice(cell, value, |a, b| invoke(a, b)); LL | twice(cell, value, |a, b| invoke(a, b));
| ^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^
| |
= note: defining type: DefId(0:20 ~ ty_param_closure_approximate_lower_bound[317d]::generic[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:11 ~ ty_param_closure_approximate_lower_bound[317d]::generic[0]::{{closure}}[0]) with closure substs [
T, T,
i16, i16,
for<'r, 's> extern "rust-call" fn((std::option::Option<std::cell::Cell<&'_#1r &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) ()>>, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) T)), for<'r, 's> extern "rust-call" fn((std::option::Option<std::cell::Cell<&'_#1r &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) ()>>, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) T)),
@ -21,7 +21,7 @@ LL | | twice(cell, value, |a, b| invoke(a, b));
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:18 ~ ty_param_closure_approximate_lower_bound[317d]::generic[0]) with substs [ = note: defining type: DefId(0:9 ~ ty_param_closure_approximate_lower_bound[317d]::generic[0]) with substs [
T, T,
] ]
@ -31,7 +31,7 @@ note: External requirements
LL | twice(cell, value, |a, b| invoke(a, b)); LL | twice(cell, value, |a, b| invoke(a, b));
| ^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^
| |
= note: defining type: DefId(0:24 ~ ty_param_closure_approximate_lower_bound[317d]::generic_fail[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:15 ~ ty_param_closure_approximate_lower_bound[317d]::generic_fail[0]::{{closure}}[0]) with closure substs [
T, T,
i16, i16,
for<'r, 's> extern "rust-call" fn((std::option::Option<std::cell::Cell<&'_#1r &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) ()>>, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) T)), for<'r, 's> extern "rust-call" fn((std::option::Option<std::cell::Cell<&'_#1r &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 'r)) ()>>, &ReLateBound(DebruijnIndex(0), BrNamed(crate0:DefIndex(0), 's)) T)),
@ -49,7 +49,7 @@ LL | |
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:21 ~ ty_param_closure_approximate_lower_bound[317d]::generic_fail[0]) with substs [ = note: defining type: DefId(0:12 ~ ty_param_closure_approximate_lower_bound[317d]::generic_fail[0]) with substs [
T, T,
] ]
@ -59,7 +59,7 @@ error[E0309]: the parameter type `T` may not live long enough
LL | twice(cell, value, |a, b| invoke(a, b)); LL | twice(cell, value, |a, b| invoke(a, b));
| ^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^
| |
= help: consider adding an explicit lifetime bound `T: ReFree(DefId(0:21 ~ ty_param_closure_approximate_lower_bound[317d]::generic_fail[0]), BrNamed(crate0:DefIndex(22), 'a))`... = help: consider adding an explicit lifetime bound `T: ReFree(DefId(0:12 ~ ty_param_closure_approximate_lower_bound[317d]::generic_fail[0]), BrNamed(crate0:DefIndex(13), 'a))`...
error: aborting due to previous error error: aborting due to previous error

4
src/test/ui/nll/ty-outlives/ty-param-closure-outlives-from-return-type.stderr
View file

@ -4,7 +4,7 @@ note: External requirements
LL | with_signature(x, |y| y) LL | with_signature(x, |y| y)
| ^^^^^ | ^^^^^
| |
= note: defining type: DefId(0:20 ~ ty_param_closure_outlives_from_return_type[317d]::no_region[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:11 ~ ty_param_closure_outlives_from_return_type[317d]::no_region[0]::{{closure}}[0]) with closure substs [
'_#1r, '_#1r,
T, T,
i32, i32,
@ -25,7 +25,7 @@ LL | |
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:17 ~ ty_param_closure_outlives_from_return_type[317d]::no_region[0]) with substs [ = note: defining type: DefId(0:8 ~ ty_param_closure_outlives_from_return_type[317d]::no_region[0]) with substs [
'_#1r, '_#1r,
T, T,
] ]

20
src/test/ui/nll/ty-outlives/ty-param-closure-outlives-from-where-clause.stderr
View file

@ -11,7 +11,7 @@ LL | | require(&x, &y)
LL | | }) LL | | })
| |_____^ | |_____^
| |
= note: defining type: DefId(0:23 ~ ty_param_closure_outlives_from_where_clause[317d]::no_region[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:14 ~ ty_param_closure_outlives_from_where_clause[317d]::no_region[0]::{{closure}}[0]) with closure substs [
T, T,
i32, i32,
extern "rust-call" fn((std::cell::Cell<&'_#1r ()>, T)), extern "rust-call" fn((std::cell::Cell<&'_#1r ()>, T)),
@ -32,7 +32,7 @@ LL | | })
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:20 ~ ty_param_closure_outlives_from_where_clause[317d]::no_region[0]) with substs [ = note: defining type: DefId(0:11 ~ ty_param_closure_outlives_from_where_clause[317d]::no_region[0]) with substs [
T, T,
] ]
@ -49,7 +49,7 @@ LL | | require(&x, &y)
LL | | }) LL | | })
| |_____^ | |_____^
| |
= help: consider adding an explicit lifetime bound `T: ReFree(DefId(0:20 ~ ty_param_closure_outlives_from_where_clause[317d]::no_region[0]), BrNamed(crate0:DefIndex(21), 'a))`... = help: consider adding an explicit lifetime bound `T: ReFree(DefId(0:11 ~ ty_param_closure_outlives_from_where_clause[317d]::no_region[0]), BrNamed(crate0:DefIndex(12), 'a))`...
note: External requirements note: External requirements
--> $DIR/ty-param-closure-outlives-from-where-clause.rs:43:26 --> $DIR/ty-param-closure-outlives-from-where-clause.rs:43:26
@ -64,7 +64,7 @@ LL | | require(&x, &y)
LL | | }) LL | | })
| |_____^ | |_____^
| |
= note: defining type: DefId(0:27 ~ ty_param_closure_outlives_from_where_clause[317d]::correct_region[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:18 ~ ty_param_closure_outlives_from_where_clause[317d]::correct_region[0]::{{closure}}[0]) with closure substs [
'_#1r, '_#1r,
T, T,
i32, i32,
@ -85,7 +85,7 @@ LL | | })
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:24 ~ ty_param_closure_outlives_from_where_clause[317d]::correct_region[0]) with substs [ = note: defining type: DefId(0:15 ~ ty_param_closure_outlives_from_where_clause[317d]::correct_region[0]) with substs [
'_#1r, '_#1r,
T, T,
] ]
@ -101,7 +101,7 @@ LL | | require(&x, &y)
LL | | }) LL | | })
| |_____^ | |_____^
| |
= note: defining type: DefId(0:32 ~ ty_param_closure_outlives_from_where_clause[317d]::wrong_region[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:23 ~ ty_param_closure_outlives_from_where_clause[317d]::wrong_region[0]::{{closure}}[0]) with closure substs [
'_#1r, '_#1r,
T, T,
i32, i32,
@ -123,7 +123,7 @@ LL | | })
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:28 ~ ty_param_closure_outlives_from_where_clause[317d]::wrong_region[0]) with substs [ = note: defining type: DefId(0:19 ~ ty_param_closure_outlives_from_where_clause[317d]::wrong_region[0]) with substs [
'_#1r, '_#1r,
T, T,
] ]
@ -139,7 +139,7 @@ LL | | require(&x, &y)
LL | | }) LL | | })
| |_____^ | |_____^
| |
= help: consider adding an explicit lifetime bound `T: ReFree(DefId(0:28 ~ ty_param_closure_outlives_from_where_clause[317d]::wrong_region[0]), BrNamed(crate0:DefIndex(29), 'a))`... = help: consider adding an explicit lifetime bound `T: ReFree(DefId(0:19 ~ ty_param_closure_outlives_from_where_clause[317d]::wrong_region[0]), BrNamed(crate0:DefIndex(20), 'a))`...
note: External requirements note: External requirements
--> $DIR/ty-param-closure-outlives-from-where-clause.rs:77:26 --> $DIR/ty-param-closure-outlives-from-where-clause.rs:77:26
@ -151,7 +151,7 @@ LL | | require(&x, &y)
LL | | }) LL | | })
| |_____^ | |_____^
| |
= note: defining type: DefId(0:37 ~ ty_param_closure_outlives_from_where_clause[317d]::outlives_region[0]::{{closure}}[0]) with closure substs [ = note: defining type: DefId(0:28 ~ ty_param_closure_outlives_from_where_clause[317d]::outlives_region[0]::{{closure}}[0]) with closure substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
T, T,
@ -173,7 +173,7 @@ LL | | })
LL | | } LL | | }
| |_^ | |_^
| |
= note: defining type: DefId(0:33 ~ ty_param_closure_outlives_from_where_clause[317d]::outlives_region[0]) with substs [ = note: defining type: DefId(0:24 ~ ty_param_closure_outlives_from_where_clause[317d]::outlives_region[0]) with substs [
'_#1r, '_#1r,
'_#2r, '_#2r,
T, T,

4
src/test/ui/parser/issue-62973.stderr
View file

@ -36,13 +36,13 @@ LL | )
| |
error: expected one of `.`, `?`, `{`, or an operator, found `}` error: expected one of `.`, `?`, `{`, or an operator, found `}`
--> $DIR/issue-62973.rs:8:1 --> $DIR/issue-62973.rs:8:2
| |
LL | fn p() { match s { v, E { [) {) } LL | fn p() { match s { v, E { [) {) }
| ----- while parsing this match expression | ----- while parsing this match expression
LL | LL |
LL | LL |
| ^ expected one of `.`, `?`, `{`, or an operator here | ^ expected one of `.`, `?`, `{`, or an operator here
error: incorrect close delimiter: `)` error: incorrect close delimiter: `)`
--> $DIR/issue-62973.rs:6:28 --> $DIR/issue-62973.rs:6:28

8
src/test/ui/parser/issue-63135.stderr
View file

@ -23,16 +23,16 @@ LL | fn i(n{...,f #
| `..` must be at the end and cannot have a trailing comma | `..` must be at the end and cannot have a trailing comma
error: expected `[`, found `}` error: expected `[`, found `}`
--> $DIR/issue-63135.rs:3:15 --> $DIR/issue-63135.rs:3:16
| |
LL | fn i(n{...,f # LL | fn i(n{...,f #
| ^ expected `[` | ^ expected `[`
error: expected one of `:` or `|`, found `)` error: expected one of `:` or `|`, found `)`
--> $DIR/issue-63135.rs:3:15 --> $DIR/issue-63135.rs:3:16
| |
LL | fn i(n{...,f # LL | fn i(n{...,f #
| ^ expected one of `:` or `|` here | ^ expected one of `:` or `|` here
error: aborting due to 5 previous errors error: aborting due to 5 previous errors

2
src/test/ui/parser/macro/macro-doc-comments-2.stderr
View file

@ -5,7 +5,7 @@ LL | macro_rules! inner {
| ------------------ when calling this macro | ------------------ when calling this macro
... ...
LL | /// Outer LL | /// Outer
| ^ no rules expected this token in macro call | ^^^^^^^^^ no rules expected this token in macro call
error: aborting due to previous error error: aborting due to previous error

3
src/test/ui/parser/missing_right_paren.rs Normal file
View file

@ -0,0 +1,3 @@
// ignore-tidy-trailing-newlines
// error-pattern: aborting due to 2 previous errors
fn main((ؼ

17
src/test/ui/parser/missing_right_paren.stderr Normal file
View file

@ -0,0 +1,17 @@
error: this file contains an un-closed delimiter
--> $DIR/missing_right_paren.rs:3:11
|
LL | fn main((ؼ
| -- ^
| ||
| |un-closed delimiter
| un-closed delimiter
error: expected one of `:` or `|`, found `)`
--> $DIR/missing_right_paren.rs:3:11
|
LL | fn main((ؼ
| ^ expected one of `:` or `|` here
error: aborting due to 2 previous errors

15
src/test/ui/structs/struct-path-self-type-mismatch.stderr
View file

@ -7,8 +7,13 @@ LL | Self { inner: 1.5f32 };
error[E0308]: mismatched types error[E0308]: mismatched types
--> $DIR/struct-path-self-type-mismatch.rs:15:20 --> $DIR/struct-path-self-type-mismatch.rs:15:20
| |
LL | impl<T> Foo<T> {
| - expected type parameter
LL | fn new<U>(u: U) -> Foo<U> {
| - found type parameter
...
LL | inner: u LL | inner: u
| ^ expected type parameter, found a different type parameter | ^ expected type parameter `T`, found type parameter `U`
| |
= note: expected type `T` = note: expected type `T`
found type `U` found type `U`
@ -18,14 +23,18 @@ LL | inner: u
error[E0308]: mismatched types error[E0308]: mismatched types
--> $DIR/struct-path-self-type-mismatch.rs:13:9 --> $DIR/struct-path-self-type-mismatch.rs:13:9
| |
LL | impl<T> Foo<T> {
| - found type parameter
LL | fn new<U>(u: U) -> Foo<U> { LL | fn new<U>(u: U) -> Foo<U> {
| ------ expected `Foo<U>` because of return type | - ------ expected `Foo<U>` because of return type
| |
| expected type parameter
LL | / Self { LL | / Self {
LL | | LL | |
LL | | inner: u LL | | inner: u
LL | | LL | |
LL | | } LL | | }
| |_________^ expected type parameter, found a different type parameter | |_________^ expected type parameter `U`, found type parameter `T`
| |
= note: expected type `Foo<U>` = note: expected type `Foo<U>`
found type `Foo<T>` found type `Foo<T>`

6
src/test/ui/structs/struct-path-self.stderr
View file

@ -1,4 +1,4 @@
error[E0071]: expected struct, variant or union type, found type parameter error[E0071]: expected struct, variant or union type, found type parameter `Self`
--> $DIR/struct-path-self.rs:5:17 --> $DIR/struct-path-self.rs:5:17
| |
LL | let s = Self {}; LL | let s = Self {};
@ -10,13 +10,13 @@ error[E0109]: type arguments are not allowed for this type
LL | let z = Self::<u8> {}; LL | let z = Self::<u8> {};
| ^^ type argument not allowed | ^^ type argument not allowed
error[E0071]: expected struct, variant or union type, found type parameter error[E0071]: expected struct, variant or union type, found type parameter `Self`
--> $DIR/struct-path-self.rs:7:17 --> $DIR/struct-path-self.rs:7:17
| |
LL | let z = Self::<u8> {}; LL | let z = Self::<u8> {};
| ^^^^^^^^^^ not a struct | ^^^^^^^^^^ not a struct
error[E0071]: expected struct, variant or union type, found type parameter error[E0071]: expected struct, variant or union type, found type parameter `Self`
--> $DIR/struct-path-self.rs:11:13 --> $DIR/struct-path-self.rs:11:13
| |
LL | Self { .. } => {} LL | Self { .. } => {}

5
src/test/ui/suggestions/type-ascription-instead-of-path-2.rs Normal file
View file

@ -0,0 +1,5 @@
fn main() -> Result<(), ()> {
vec![Ok(2)].into_iter().collect:<Result<Vec<_>,_>>()?;
//~^ ERROR expected `::`, found `(`
Ok(())
}

13
src/test/ui/suggestions/type-ascription-instead-of-path-2.stderr Normal file
View file

@ -0,0 +1,13 @@
error: expected `::`, found `(`
--> $DIR/type-ascription-instead-of-path-2.rs:2:55
|
LL | vec![Ok(2)].into_iter().collect:<Result<Vec<_>,_>>()?;
| - ^ expected `::`
| |
| help: maybe write a path separator here: `::`
|
= note: `#![feature(type_ascription)]` lets you annotate an expression with a type: `<expr>: <type>`
= note: for more information, see https://github.com/rust-lang/rust/issues/23416
error: aborting due to previous error

30
src/test/ui/type-alias-enum-variants/enum-variant-generic-args.stderr
View file

@ -1,8 +1,11 @@
error[E0308]: mismatched types error[E0308]: mismatched types
--> $DIR/enum-variant-generic-args.rs:13:25 --> $DIR/enum-variant-generic-args.rs:13:25
| |
LL | impl<T> Enum<T> {
| - this type parameter
LL | fn ts_variant() {
LL | Self::TSVariant(()); LL | Self::TSVariant(());
| ^^ expected type parameter, found () | ^^ expected type parameter `T`, found ()
| |
= note: expected type `T` = note: expected type `T`
found type `()` found type `()`
@ -24,8 +27,11 @@ LL | Self::<()>::TSVariant(());
error[E0308]: mismatched types error[E0308]: mismatched types
--> $DIR/enum-variant-generic-args.rs:17:31 --> $DIR/enum-variant-generic-args.rs:17:31
| |
LL | impl<T> Enum<T> {
| - this type parameter
...
LL | Self::<()>::TSVariant(()); LL | Self::<()>::TSVariant(());
| ^^ expected type parameter, found () | ^^ expected type parameter `T`, found ()
| |
= note: expected type `T` = note: expected type `T`
found type `()` found type `()`
@ -47,8 +53,11 @@ LL | Self::<()>::TSVariant::<()>(());
error[E0308]: mismatched types error[E0308]: mismatched types
--> $DIR/enum-variant-generic-args.rs:26:29 --> $DIR/enum-variant-generic-args.rs:26:29
| |
LL | impl<T> Enum<T> {
| - this type parameter
...
LL | Self::SVariant { v: () }; LL | Self::SVariant { v: () };
| ^^ expected type parameter, found () | ^^ expected type parameter `T`, found ()
| |
= note: expected type `T` = note: expected type `T`
found type `()` found type `()`
@ -64,8 +73,11 @@ LL | Self::SVariant::<()> { v: () };
error[E0308]: mismatched types error[E0308]: mismatched types
--> $DIR/enum-variant-generic-args.rs:28:35 --> $DIR/enum-variant-generic-args.rs:28:35
| |
LL | impl<T> Enum<T> {
| - this type parameter
...
LL | Self::SVariant::<()> { v: () }; LL | Self::SVariant::<()> { v: () };
| ^^ expected type parameter, found () | ^^ expected type parameter `T`, found ()
| |
= note: expected type `T` = note: expected type `T`
found type `()` found type `()`
@ -81,8 +93,11 @@ LL | Self::<()>::SVariant { v: () };
error[E0308]: mismatched types error[E0308]: mismatched types
--> $DIR/enum-variant-generic-args.rs:31:35 --> $DIR/enum-variant-generic-args.rs:31:35
| |
LL | impl<T> Enum<T> {
| - this type parameter
...
LL | Self::<()>::SVariant { v: () }; LL | Self::<()>::SVariant { v: () };
| ^^ expected type parameter, found () | ^^ expected type parameter `T`, found ()
| |
= note: expected type `T` = note: expected type `T`
found type `()` found type `()`
@ -104,8 +119,11 @@ LL | Self::<()>::SVariant::<()> { v: () };
error[E0308]: mismatched types error[E0308]: mismatched types
--> $DIR/enum-variant-generic-args.rs:34:41 --> $DIR/enum-variant-generic-args.rs:34:41
| |
LL | impl<T> Enum<T> {
| - this type parameter
...
LL | Self::<()>::SVariant::<()> { v: () }; LL | Self::<()>::SVariant::<()> { v: () };
| ^^ expected type parameter, found () | ^^ expected type parameter `T`, found ()
| |
= note: expected type `T` = note: expected type `T`
found type `()` found type `()`

8
src/test/ui/type/type-error-break-tail.rs Normal file
View file

@ -0,0 +1,8 @@
fn loop_ending() -> i32 {
loop {
if false { break; } //~ ERROR mismatched types
return 42;
}
}
fn main() {}

18
src/test/ui/type/type-error-break-tail.stderr Normal file
View file

@ -0,0 +1,18 @@
error[E0308]: mismatched types
--> $DIR/type-error-break-tail.rs:3:20
|
LL | fn loop_ending() -> i32 {
| --- expected `i32` because of return type
LL | loop {
LL | if false { break; }
| ^^^^^
| |
| expected i32, found ()
| help: give it a value of the expected type: `break 42`
|
= note: expected type `i32`
found type `()`
error: aborting due to previous error
For more information about this error, try `rustc --explain E0308`.

2
src/test/ui/type/type-parameter-names.rs
View file

@ -6,7 +6,7 @@ fn foo<Foo, Bar>(x: Foo) -> Bar {
//~^ ERROR mismatched types //~^ ERROR mismatched types
//~| expected type `Bar` //~| expected type `Bar`
//~| found type `Foo` //~| found type `Foo`
//~| expected type parameter, found a different type parameter //~| expected type parameter `Bar`, found type parameter `Foo`
} }
fn main() {} fn main() {}

7
src/test/ui/type/type-parameter-names.stderr
View file

@ -2,9 +2,12 @@ error[E0308]: mismatched types
--> $DIR/type-parameter-names.rs:5:5 --> $DIR/type-parameter-names.rs:5:5
| |
LL | fn foo<Foo, Bar>(x: Foo) -> Bar { LL | fn foo<Foo, Bar>(x: Foo) -> Bar {
| --- expected `Bar` because of return type | --- --- --- expected `Bar` because of return type
| | |
| | expected type parameter
| found type parameter
LL | x LL | x
| ^ expected type parameter, found a different type parameter | ^ expected type parameter `Bar`, found type parameter `Foo`
| |
= note: expected type `Bar` = note: expected type `Bar`
found type `Foo` found type `Foo`

2
src/test/ui/type/type-params-in-different-spaces-1.rs
View file

@ -5,7 +5,7 @@ trait BrokenAdd: Copy + Add<Output=Self> {
*self + rhs //~ ERROR mismatched types *self + rhs //~ ERROR mismatched types
//~| expected type `Self` //~| expected type `Self`
//~| found type `T` //~| found type `T`
//~| expected type parameter, found a different type parameter //~| expected type parameter `Self`, found type parameter `T`
} }
} }

12
src/test/ui/type/type-params-in-different-spaces-1.stderr
View file

@ -1,8 +1,16 @@
error[E0308]: mismatched types error[E0308]: mismatched types
--> $DIR/type-params-in-different-spaces-1.rs:5:17 --> $DIR/type-params-in-different-spaces-1.rs:5:17
| |
LL | *self + rhs LL | / trait BrokenAdd: Copy + Add<Output=Self> {
| ^^^ expected type parameter, found a different type parameter LL | | fn broken_add<T>(&self, rhs: T) -> Self {
| | - found type parameter
LL | | *self + rhs
| | ^^^ expected type parameter `Self`, found type parameter `T`
LL | |
... |
LL | | }
LL | | }
| |_- expected type parameter
| |
= note: expected type `Self` = note: expected type `Self`
found type `T` found type `T`

14
src/test/ui/type/type-params-in-different-spaces-3.stderr
View file

@ -1,10 +1,16 @@
error[E0308]: mismatched types error[E0308]: mismatched types
--> $DIR/type-params-in-different-spaces-3.rs:3:9 --> $DIR/type-params-in-different-spaces-3.rs:3:9
| |
LL | fn test<X>(u: X) -> Self { LL | / trait Tr : Sized {
| ---- expected `Self` because of return type LL | | fn test<X>(u: X) -> Self {
LL | u | | - ---- expected `Self` because of return type
| ^ expected type parameter, found a different type parameter | | |
| | found type parameter
LL | | u
| | ^ expected type parameter `Self`, found type parameter `X`
LL | | }
LL | | }
| |_- expected type parameter
| |
= note: expected type `Self` = note: expected type `Self`
found type `X` found type `X`