From d5b6510bfb8484a964428fe44e2a66eebb15e66e Mon Sep 17 00:00:00 2001 From: Oli Scherer Date: Wed, 9 Feb 2022 16:44:17 +0000 Subject: [PATCH] Have the spans of TAIT type conflict errors point to the actual site instead of the owning function --- compiler/rustc_borrowck/src/nll.rs | 8 ++--- .../src/region_infer/opaque_types.rs | 32 ++++++++--------- compiler/rustc_borrowck/src/type_check/mod.rs | 16 ++++----- .../rustc_infer/src/infer/opaque_types.rs | 36 ++----------------- .../src/infer/opaque_types/table.rs | 4 +-- compiler/rustc_infer/src/infer/undo_log.rs | 4 +-- compiler/rustc_middle/src/mir/query.rs | 4 +-- compiler/rustc_middle/src/ty/mod.rs | 32 +++++++++++++++++ .../rustc_trait_selection/src/opaque_types.rs | 14 ++++---- compiler/rustc_typeck/src/collect/type_of.rs | 27 +++++++------- src/test/ui/impl-trait/issue-86465.rs | 2 +- src/test/ui/impl-trait/issue-86465.stderr | 12 +++---- .../different_defining_uses.rs | 2 +- .../different_defining_uses.stderr | 12 +++---- .../different_lifetimes_defining_uses.rs | 2 +- .../different_lifetimes_defining_uses.stderr | 12 +++---- .../generic_different_defining_uses.rs | 2 +- .../generic_different_defining_uses.stderr | 12 +++---- .../generic_duplicate_param_use3.rs | 2 +- .../generic_duplicate_param_use3.stderr | 12 +++---- .../generic_duplicate_param_use5.rs | 2 +- .../generic_duplicate_param_use5.stderr | 12 +++---- .../generic_duplicate_param_use6.rs | 2 +- .../generic_duplicate_param_use6.stderr | 12 +++---- .../generic_duplicate_param_use8.rs | 2 +- .../generic_duplicate_param_use8.stderr | 12 +++---- .../generic_duplicate_param_use9.rs | 2 +- .../generic_duplicate_param_use9.stderr | 12 +++---- .../issue-52843-closure-constrain.stderr | 8 ++--- .../multiple-def-uses-in-one-fn-infer.rs | 2 +- .../multiple-def-uses-in-one-fn-infer.stderr | 12 +++---- .../multiple-def-uses-in-one-fn-lifetimes.rs | 2 +- ...ltiple-def-uses-in-one-fn-lifetimes.stderr | 12 +++---- .../multiple-def-uses-in-one-fn2.rs | 2 +- .../multiple-def-uses-in-one-fn2.stderr | 12 +++---- .../not_a_defining_use.rs | 2 +- .../not_a_defining_use.stderr | 12 +++---- 37 files changed, 180 insertions(+), 187 deletions(-) diff --git a/compiler/rustc_borrowck/src/nll.rs b/compiler/rustc_borrowck/src/nll.rs index 03b4a6ea983..9242c6aeb8b 100644 --- a/compiler/rustc_borrowck/src/nll.rs +++ b/compiler/rustc_borrowck/src/nll.rs @@ -8,7 +8,7 @@ use rustc_middle::mir::{ BasicBlock, Body, ClosureOutlivesSubject, ClosureRegionRequirements, LocalKind, Location, Promoted, }; -use rustc_middle::ty::{self, OpaqueTypeKey, Region, RegionVid, Ty}; +use rustc_middle::ty::{self, OpaqueHiddenType, OpaqueTypeKey, Region, RegionVid}; use rustc_span::symbol::sym; use std::env; use std::fmt::Debug; @@ -43,7 +43,7 @@ pub type PoloniusOutput = Output; /// closure requirements to propagate, and any generated errors. crate struct NllOutput<'tcx> { pub regioncx: RegionInferenceContext<'tcx>, - pub opaque_type_values: VecMap, Ty<'tcx>>, + pub opaque_type_values: VecMap, OpaqueHiddenType<'tcx>>, pub polonius_input: Option>, pub polonius_output: Option>, pub opt_closure_req: Option>, @@ -305,7 +305,7 @@ pub(crate) fn compute_regions<'cx, 'tcx>( infcx.set_tainted_by_errors(); } - let remapped_opaque_tys = regioncx.infer_opaque_types(&infcx, opaque_type_values, body.span); + let remapped_opaque_tys = regioncx.infer_opaque_types(&infcx, opaque_type_values); NllOutput { regioncx, @@ -372,7 +372,7 @@ pub(super) fn dump_annotation<'a, 'tcx>( body: &Body<'tcx>, regioncx: &RegionInferenceContext<'tcx>, closure_region_requirements: &Option>, - opaque_type_values: &VecMap, Ty<'tcx>>, + opaque_type_values: &VecMap, OpaqueHiddenType<'tcx>>, errors: &mut crate::error::BorrowckErrors<'tcx>, ) { let tcx = infcx.tcx; diff --git a/compiler/rustc_borrowck/src/region_infer/opaque_types.rs b/compiler/rustc_borrowck/src/region_infer/opaque_types.rs index a2378802802..f454141dc52 100644 --- a/compiler/rustc_borrowck/src/region_infer/opaque_types.rs +++ b/compiler/rustc_borrowck/src/region_infer/opaque_types.rs @@ -3,7 +3,7 @@ use rustc_data_structures::vec_map::VecMap; use rustc_hir::OpaqueTyOrigin; use rustc_infer::infer::InferCtxt; use rustc_middle::ty::subst::GenericArgKind; -use rustc_middle::ty::{self, OpaqueTypeKey, Ty, TyCtxt, TypeFoldable}; +use rustc_middle::ty::{self, OpaqueHiddenType, OpaqueTypeKey, TyCtxt, TypeFoldable}; use rustc_span::Span; use rustc_trait_selection::opaque_types::InferCtxtExt; @@ -53,15 +53,12 @@ impl<'tcx> RegionInferenceContext<'tcx> { pub(crate) fn infer_opaque_types( &self, infcx: &InferCtxt<'_, 'tcx>, - opaque_ty_decls: VecMap, (Ty<'tcx>, Span, OpaqueTyOrigin)>, - span: Span, - ) -> VecMap, Ty<'tcx>> { + opaque_ty_decls: VecMap, (OpaqueHiddenType<'tcx>, OpaqueTyOrigin)>, + ) -> VecMap, OpaqueHiddenType<'tcx>> { opaque_ty_decls .into_iter() - .map(|(opaque_type_key, (concrete_type, decl_span, origin))| { + .map(|(opaque_type_key, (concrete_type, origin))| { let substs = opaque_type_key.substs; - // FIXME: why are the spans in decl_span often DUMMY_SP? - let span = decl_span.substitute_dummy(span); debug!(?concrete_type, ?substs); let mut subst_regions = vec![self.universal_regions.fr_static]; @@ -85,7 +82,7 @@ impl<'tcx> RegionInferenceContext<'tcx> { None => { subst_regions.push(vid); infcx.tcx.sess.delay_span_bug( - span, + concrete_type.span, "opaque type with non-universal region substs", ); infcx.tcx.lifetimes.re_static @@ -113,17 +110,18 @@ impl<'tcx> RegionInferenceContext<'tcx> { let remapped_type = infcx.infer_opaque_definition_from_instantiation( opaque_type_key, universal_concrete_type, - span, ); - - ( + let ty = if check_opaque_type_parameter_valid( + infcx.tcx, opaque_type_key, - if check_opaque_type_parameter_valid(infcx.tcx, opaque_type_key, origin, span) { - remapped_type - } else { - infcx.tcx.ty_error() - }, - ) + origin, + concrete_type.span, + ) { + remapped_type + } else { + infcx.tcx.ty_error() + }; + (opaque_type_key, OpaqueHiddenType { ty, span: concrete_type.span }) }) .collect() } diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs index 2d4bb272df5..3ee0aafebfd 100644 --- a/compiler/rustc_borrowck/src/type_check/mod.rs +++ b/compiler/rustc_borrowck/src/type_check/mod.rs @@ -31,8 +31,8 @@ use rustc_middle::ty::cast::CastTy; use rustc_middle::ty::fold::TypeFoldable; use rustc_middle::ty::subst::{GenericArgKind, SubstsRef, UserSubsts}; use rustc_middle::ty::{ - self, CanonicalUserTypeAnnotation, CanonicalUserTypeAnnotations, OpaqueTypeKey, RegionVid, - ToPredicate, Ty, TyCtxt, UserType, UserTypeAnnotationIndex, + self, CanonicalUserTypeAnnotation, CanonicalUserTypeAnnotations, OpaqueHiddenType, + OpaqueTypeKey, RegionVid, ToPredicate, Ty, TyCtxt, UserType, UserTypeAnnotationIndex, }; use rustc_span::def_id::CRATE_DEF_ID; use rustc_span::{Span, DUMMY_SP}; @@ -225,21 +225,21 @@ pub(crate) fn type_check<'mir, 'tcx>( ), ) .unwrap(); - let mut hidden_type = infcx.resolve_vars_if_possible(decl.hidden_type.ty); + let mut hidden_type = infcx.resolve_vars_if_possible(decl.hidden_type); trace!( "finalized opaque type {:?} to {:#?}", opaque_type_key, - hidden_type.kind() + hidden_type.ty.kind() ); if hidden_type.has_infer_types_or_consts() { infcx.tcx.sess.delay_span_bug( decl.hidden_type.span, - &format!("could not resolve {:#?}", hidden_type.kind()), + &format!("could not resolve {:#?}", hidden_type.ty.kind()), ); - hidden_type = infcx.tcx.ty_error(); + hidden_type.ty = infcx.tcx.ty_error(); } - (opaque_type_key, (hidden_type, decl.hidden_type.span, decl.origin)) + (opaque_type_key, (hidden_type, decl.origin)) }) .collect() }, @@ -905,7 +905,7 @@ struct BorrowCheckContext<'a, 'tcx> { crate struct MirTypeckResults<'tcx> { crate constraints: MirTypeckRegionConstraints<'tcx>, crate universal_region_relations: Frozen>, - crate opaque_type_values: VecMap, (Ty<'tcx>, Span, OpaqueTyOrigin)>, + crate opaque_type_values: VecMap, (OpaqueHiddenType<'tcx>, OpaqueTyOrigin)>, } /// A collection of region constraints that must be satisfied for the diff --git a/compiler/rustc_infer/src/infer/opaque_types.rs b/compiler/rustc_infer/src/infer/opaque_types.rs index 38b092cfd70..ba74aa804e3 100644 --- a/compiler/rustc_infer/src/infer/opaque_types.rs +++ b/compiler/rustc_infer/src/infer/opaque_types.rs @@ -8,7 +8,9 @@ use rustc_hir as hir; use rustc_middle::traits::ObligationCause; use rustc_middle::ty::fold::BottomUpFolder; use rustc_middle::ty::subst::{GenericArgKind, Subst}; -use rustc_middle::ty::{self, OpaqueTypeKey, Ty, TyCtxt, TypeFoldable, TypeVisitor}; +use rustc_middle::ty::{ + self, OpaqueHiddenType, OpaqueTypeKey, Ty, TyCtxt, TypeFoldable, TypeVisitor, +}; use rustc_span::Span; use std::ops::ControlFlow; @@ -35,38 +37,6 @@ pub struct OpaqueTypeDecl<'tcx> { pub origin: hir::OpaqueTyOrigin, } -#[derive(Copy, Clone, Debug, TypeFoldable)] -pub struct OpaqueHiddenType<'tcx> { - /// The span of this particular definition of the opaque type. So - /// for example: - /// - /// ```ignore (incomplete snippet) - /// type Foo = impl Baz; - /// fn bar() -> Foo { - /// // ^^^ This is the span we are looking for! - /// } - /// ``` - /// - /// In cases where the fn returns `(impl Trait, impl Trait)` or - /// other such combinations, the result is currently - /// over-approximated, but better than nothing. - pub span: Span, - - /// The type variable that represents the value of the opaque type - /// that we require. In other words, after we compile this function, - /// we will be created a constraint like: - /// - /// Foo<'a, T> = ?C - /// - /// where `?C` is the value of this type variable. =) It may - /// naturally refer to the type and lifetime parameters in scope - /// in this function, though ultimately it should only reference - /// those that are arguments to `Foo` in the constraint above. (In - /// other words, `?C` should not include `'b`, even though it's a - /// lifetime parameter on `foo`.) - pub ty: Ty<'tcx>, -} - impl<'a, 'tcx> InferCtxt<'a, 'tcx> { pub fn handle_opaque_type( &self, diff --git a/compiler/rustc_infer/src/infer/opaque_types/table.rs b/compiler/rustc_infer/src/infer/opaque_types/table.rs index 55da42e98f4..fb12da0cc13 100644 --- a/compiler/rustc_infer/src/infer/opaque_types/table.rs +++ b/compiler/rustc_infer/src/infer/opaque_types/table.rs @@ -1,11 +1,11 @@ use rustc_data_structures::undo_log::UndoLogs; use rustc_hir::OpaqueTyOrigin; -use rustc_middle::ty::{self, OpaqueTypeKey, Ty}; +use rustc_middle::ty::{self, OpaqueHiddenType, OpaqueTypeKey, Ty}; use rustc_span::DUMMY_SP; use crate::infer::{InferCtxtUndoLogs, UndoLog}; -use super::{OpaqueHiddenType, OpaqueTypeDecl, OpaqueTypeMap}; +use super::{OpaqueTypeDecl, OpaqueTypeMap}; #[derive(Default, Debug, Clone)] pub struct OpaqueTypeStorage<'tcx> { diff --git a/compiler/rustc_infer/src/infer/undo_log.rs b/compiler/rustc_infer/src/infer/undo_log.rs index 49bef4face3..1b696f21cbc 100644 --- a/compiler/rustc_infer/src/infer/undo_log.rs +++ b/compiler/rustc_infer/src/infer/undo_log.rs @@ -4,15 +4,13 @@ use rustc_data_structures::snapshot_vec as sv; use rustc_data_structures::undo_log::{Rollback, UndoLogs}; use rustc_data_structures::unify as ut; use rustc_middle::infer::unify_key::RegionVidKey; -use rustc_middle::ty::{self, OpaqueTypeKey}; +use rustc_middle::ty::{self, OpaqueHiddenType, OpaqueTypeKey}; use crate::{ infer::{region_constraints, type_variable, InferCtxtInner}, traits, }; -use super::opaque_types::OpaqueHiddenType; - pub struct Snapshot<'tcx> { pub(crate) undo_len: usize, _marker: PhantomData<&'tcx ()>, diff --git a/compiler/rustc_middle/src/mir/query.rs b/compiler/rustc_middle/src/mir/query.rs index 00d1370625f..811b9da3740 100644 --- a/compiler/rustc_middle/src/mir/query.rs +++ b/compiler/rustc_middle/src/mir/query.rs @@ -1,7 +1,7 @@ //! Values computed by queries that use MIR. use crate::mir::{Body, Promoted}; -use crate::ty::{self, Ty, TyCtxt}; +use crate::ty::{self, OpaqueHiddenType, Ty, TyCtxt}; use rustc_data_structures::stable_map::FxHashMap; use rustc_data_structures::vec_map::VecMap; use rustc_errors::ErrorGuaranteed; @@ -242,7 +242,7 @@ pub struct BorrowCheckResult<'tcx> { /// All the opaque types that are restricted to concrete types /// by this function. Unlike the value in `TypeckResults`, this has /// unerased regions. - pub concrete_opaque_types: VecMap, Ty<'tcx>>, + pub concrete_opaque_types: VecMap, OpaqueHiddenType<'tcx>>, pub closure_requirements: Option>, pub used_mut_upvars: SmallVec<[Field; 8]>, pub tainted_by_errors: Option, diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs index 4208ef1a7f4..069cf32e515 100644 --- a/compiler/rustc_middle/src/ty/mod.rs +++ b/compiler/rustc_middle/src/ty/mod.rs @@ -1081,6 +1081,38 @@ pub struct OpaqueTypeKey<'tcx> { pub substs: SubstsRef<'tcx>, } +#[derive(Copy, Clone, Debug, TypeFoldable, HashStable, TyEncodable, TyDecodable)] +pub struct OpaqueHiddenType<'tcx> { + /// The span of this particular definition of the opaque type. So + /// for example: + /// + /// ```ignore (incomplete snippet) + /// type Foo = impl Baz; + /// fn bar() -> Foo { + /// // ^^^ This is the span we are looking for! + /// } + /// ``` + /// + /// In cases where the fn returns `(impl Trait, impl Trait)` or + /// other such combinations, the result is currently + /// over-approximated, but better than nothing. + pub span: Span, + + /// The type variable that represents the value of the opaque type + /// that we require. In other words, after we compile this function, + /// we will be created a constraint like: + /// + /// Foo<'a, T> = ?C + /// + /// where `?C` is the value of this type variable. =) It may + /// naturally refer to the type and lifetime parameters in scope + /// in this function, though ultimately it should only reference + /// those that are arguments to `Foo` in the constraint above. (In + /// other words, `?C` should not include `'b`, even though it's a + /// lifetime parameter on `foo`.) + pub ty: Ty<'tcx>, +} + rustc_index::newtype_index! { /// "Universes" are used during type- and trait-checking in the /// presence of `for<..>` binders to control what sets of names are diff --git a/compiler/rustc_trait_selection/src/opaque_types.rs b/compiler/rustc_trait_selection/src/opaque_types.rs index c5531222fef..eb70de48368 100644 --- a/compiler/rustc_trait_selection/src/opaque_types.rs +++ b/compiler/rustc_trait_selection/src/opaque_types.rs @@ -5,15 +5,14 @@ use rustc_infer::infer::error_reporting::unexpected_hidden_region_diagnostic; use rustc_infer::infer::InferCtxt; use rustc_middle::ty::fold::{TypeFoldable, TypeFolder}; use rustc_middle::ty::subst::{GenericArg, GenericArgKind, InternalSubsts}; -use rustc_middle::ty::{self, OpaqueTypeKey, Ty, TyCtxt}; +use rustc_middle::ty::{self, OpaqueHiddenType, OpaqueTypeKey, Ty, TyCtxt}; use rustc_span::Span; pub trait InferCtxtExt<'tcx> { fn infer_opaque_definition_from_instantiation( &self, opaque_type_key: OpaqueTypeKey<'tcx>, - instantiated_ty: Ty<'tcx>, - span: Span, + instantiated_ty: OpaqueHiddenType<'tcx>, ) -> Ty<'tcx>; } @@ -45,8 +44,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> { fn infer_opaque_definition_from_instantiation( &self, opaque_type_key: OpaqueTypeKey<'tcx>, - instantiated_ty: Ty<'tcx>, - span: Span, + instantiated_ty: OpaqueHiddenType<'tcx>, ) -> Ty<'tcx> { if self.is_tainted_by_errors() { return self.tcx.ty_error(); @@ -69,12 +67,12 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> { // Convert the type from the function into a type valid outside // the function, by replacing invalid regions with 'static, // after producing an error for each of them. - let definition_ty = instantiated_ty.fold_with(&mut ReverseMapper::new( + let definition_ty = instantiated_ty.ty.fold_with(&mut ReverseMapper::new( self.tcx, def_id, map, - instantiated_ty, - span, + instantiated_ty.ty, + instantiated_ty.span, )); debug!(?definition_ty); diff --git a/compiler/rustc_typeck/src/collect/type_of.rs b/compiler/rustc_typeck/src/collect/type_of.rs index 885713cd2f3..4e1edd17194 100644 --- a/compiler/rustc_typeck/src/collect/type_of.rs +++ b/compiler/rustc_typeck/src/collect/type_of.rs @@ -358,6 +358,7 @@ pub(super) fn type_of(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> { .concrete_opaque_types .get_value_matching(|(key, _)| key.def_id == def_id.to_def_id()) .copied() + .map(|concrete| concrete.ty) .unwrap_or_else(|| { let table = tcx.typeck(owner); if let Some(_) = table.tainted_by_errors { @@ -556,7 +557,7 @@ fn find_opaque_ty_constraints(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Ty<'_> { /// with the first type that we find, and then later types are /// checked against it (we also carry the span of that first /// type). - found: Option<(Span, Ty<'tcx>)>, + found: Option>, } impl ConstraintLocator<'_> { @@ -580,7 +581,7 @@ fn find_opaque_ty_constraints(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Ty<'_> { // ``` let tables = self.tcx.typeck(def_id); if let Some(_) = tables.tainted_by_errors { - self.found = Some((DUMMY_SP, self.tcx.ty_error())); + self.found = Some(ty::OpaqueHiddenType { span: DUMMY_SP, ty: self.tcx.ty_error() }); return; } if tables.concrete_opaque_types.get(&self.def_id).is_none() { @@ -590,7 +591,7 @@ fn find_opaque_ty_constraints(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Ty<'_> { // Use borrowck to get the type with unerased regions. let concrete_opaque_types = &self.tcx.mir_borrowck(def_id).concrete_opaque_types; debug!(?concrete_opaque_types); - for (opaque_type_key, concrete_type) in concrete_opaque_types { + for &(opaque_type_key, concrete_type) in concrete_opaque_types { if opaque_type_key.def_id != self.def_id { // Ignore constraints for other opaque types. continue; @@ -598,26 +599,22 @@ fn find_opaque_ty_constraints(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Ty<'_> { debug!(?concrete_type, ?opaque_type_key.substs, "found constraint"); - // FIXME(oli-obk): trace the actual span from inference to improve errors. - let span = self.tcx.def_span(def_id); - - if let Some((prev_span, prev_ty)) = self.found { - if *concrete_type != prev_ty && !(*concrete_type, prev_ty).references_error() { - debug!(?span); + if let Some(prev) = self.found { + if concrete_type.ty != prev.ty && !(concrete_type, prev).references_error() { // Found different concrete types for the opaque type. let mut err = self.tcx.sess.struct_span_err( - span, + concrete_type.span, "concrete type differs from previous defining opaque type use", ); err.span_label( - span, - format!("expected `{}`, got `{}`", prev_ty, concrete_type), + concrete_type.span, + format!("expected `{}`, got `{}`", prev.ty, concrete_type.ty), ); - err.span_note(prev_span, "previous use here"); + err.span_note(prev.span, "previous use here"); err.emit(); } } else { - self.found = Some((span, *concrete_type)); + self.found = Some(concrete_type); } } } @@ -692,7 +689,7 @@ fn find_opaque_ty_constraints(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Ty<'_> { } match locator.found { - Some((_, ty)) => ty, + Some(hidden) => hidden.ty, None => { let span = tcx.def_span(def_id); let name = tcx.item_name(tcx.parent(def_id.to_def_id()).unwrap()); diff --git a/src/test/ui/impl-trait/issue-86465.rs b/src/test/ui/impl-trait/issue-86465.rs index a6976daff01..a79bb6474d8 100644 --- a/src/test/ui/impl-trait/issue-86465.rs +++ b/src/test/ui/impl-trait/issue-86465.rs @@ -3,8 +3,8 @@ type X<'a, 'b> = impl std::fmt::Debug; fn f<'t, 'u>(a: &'t u32, b: &'u u32) -> (X<'t, 'u>, X<'u, 't>) { - //~^ ERROR concrete type differs from previous defining opaque type use (a, a) + //~^ ERROR concrete type differs from previous defining opaque type use } fn main() {} diff --git a/src/test/ui/impl-trait/issue-86465.stderr b/src/test/ui/impl-trait/issue-86465.stderr index 595b16aa685..fc7bad60183 100644 --- a/src/test/ui/impl-trait/issue-86465.stderr +++ b/src/test/ui/impl-trait/issue-86465.stderr @@ -1,14 +1,14 @@ error: concrete type differs from previous defining opaque type use - --> $DIR/issue-86465.rs:5:1 + --> $DIR/issue-86465.rs:6:5 | -LL | fn f<'t, 'u>(a: &'t u32, b: &'u u32) -> (X<'t, 'u>, X<'u, 't>) { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `&'a u32`, got `&'b u32` +LL | (a, a) + | ^^^^^^ expected `&'a u32`, got `&'b u32` | note: previous use here - --> $DIR/issue-86465.rs:5:1 + --> $DIR/issue-86465.rs:6:5 | -LL | fn f<'t, 'u>(a: &'t u32, b: &'u u32) -> (X<'t, 'u>, X<'u, 't>) { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | (a, a) + | ^^^^^^ error: aborting due to previous error diff --git a/src/test/ui/type-alias-impl-trait/different_defining_uses.rs b/src/test/ui/type-alias-impl-trait/different_defining_uses.rs index 272af7a5204..4505c4d9524 100644 --- a/src/test/ui/type-alias-impl-trait/different_defining_uses.rs +++ b/src/test/ui/type-alias-impl-trait/different_defining_uses.rs @@ -10,6 +10,6 @@ fn foo() -> Foo { } fn bar() -> Foo { - //~^ ERROR concrete type differs from previous 42i32 + //~^ ERROR concrete type differs from previous } diff --git a/src/test/ui/type-alias-impl-trait/different_defining_uses.stderr b/src/test/ui/type-alias-impl-trait/different_defining_uses.stderr index eaa716bc71c..a8b4cd7afe8 100644 --- a/src/test/ui/type-alias-impl-trait/different_defining_uses.stderr +++ b/src/test/ui/type-alias-impl-trait/different_defining_uses.stderr @@ -1,14 +1,14 @@ error: concrete type differs from previous defining opaque type use - --> $DIR/different_defining_uses.rs:12:1 + --> $DIR/different_defining_uses.rs:13:5 | -LL | fn bar() -> Foo { - | ^^^^^^^^^^^^^^^ expected `&'static str`, got `i32` +LL | 42i32 + | ^^^^^ expected `&'static str`, got `i32` | note: previous use here - --> $DIR/different_defining_uses.rs:8:1 + --> $DIR/different_defining_uses.rs:9:5 | -LL | fn foo() -> Foo { - | ^^^^^^^^^^^^^^^ +LL | "" + | ^^ error: aborting due to previous error diff --git a/src/test/ui/type-alias-impl-trait/different_lifetimes_defining_uses.rs b/src/test/ui/type-alias-impl-trait/different_lifetimes_defining_uses.rs index d0001976d65..4f424b8c665 100644 --- a/src/test/ui/type-alias-impl-trait/different_lifetimes_defining_uses.rs +++ b/src/test/ui/type-alias-impl-trait/different_lifetimes_defining_uses.rs @@ -8,8 +8,8 @@ fn foo<'a, 'b>(a: &'a u32, b: &'b u32) -> OneLifetime<'a, 'b> { } fn bar<'a, 'b>(a: &'a u32, b: &'b u32) -> OneLifetime<'a, 'b> { - //~^ ERROR: concrete type differs from previous defining opaque type use b + //~^ ERROR: concrete type differs from previous defining opaque type use } fn main() {} diff --git a/src/test/ui/type-alias-impl-trait/different_lifetimes_defining_uses.stderr b/src/test/ui/type-alias-impl-trait/different_lifetimes_defining_uses.stderr index 9493a59cf1e..0c50a84e894 100644 --- a/src/test/ui/type-alias-impl-trait/different_lifetimes_defining_uses.stderr +++ b/src/test/ui/type-alias-impl-trait/different_lifetimes_defining_uses.stderr @@ -1,14 +1,14 @@ error: concrete type differs from previous defining opaque type use - --> $DIR/different_lifetimes_defining_uses.rs:10:1 + --> $DIR/different_lifetimes_defining_uses.rs:11:5 | -LL | fn bar<'a, 'b>(a: &'a u32, b: &'b u32) -> OneLifetime<'a, 'b> { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `&'a u32`, got `&'b u32` +LL | b + | ^ expected `&'a u32`, got `&'b u32` | note: previous use here - --> $DIR/different_lifetimes_defining_uses.rs:6:1 + --> $DIR/different_lifetimes_defining_uses.rs:7:5 | -LL | fn foo<'a, 'b>(a: &'a u32, b: &'b u32) -> OneLifetime<'a, 'b> { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | a + | ^ error: aborting due to previous error diff --git a/src/test/ui/type-alias-impl-trait/generic_different_defining_uses.rs b/src/test/ui/type-alias-impl-trait/generic_different_defining_uses.rs index 07535130758..8b683ad2828 100644 --- a/src/test/ui/type-alias-impl-trait/generic_different_defining_uses.rs +++ b/src/test/ui/type-alias-impl-trait/generic_different_defining_uses.rs @@ -9,6 +9,6 @@ fn my_iter(t: T) -> MyIter { } fn my_iter2(t: T) -> MyIter { - //~^ ERROR concrete type differs from previous Some(t).into_iter() + //~^ ERROR concrete type differs from previous } diff --git a/src/test/ui/type-alias-impl-trait/generic_different_defining_uses.stderr b/src/test/ui/type-alias-impl-trait/generic_different_defining_uses.stderr index f8a058170e3..47ac3346259 100644 --- a/src/test/ui/type-alias-impl-trait/generic_different_defining_uses.stderr +++ b/src/test/ui/type-alias-impl-trait/generic_different_defining_uses.stderr @@ -1,14 +1,14 @@ error: concrete type differs from previous defining opaque type use - --> $DIR/generic_different_defining_uses.rs:11:1 + --> $DIR/generic_different_defining_uses.rs:12:5 | -LL | fn my_iter2(t: T) -> MyIter { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `std::iter::Once`, got `std::option::IntoIter` +LL | Some(t).into_iter() + | ^^^^^^^^^^^^^^^^^^^ expected `std::iter::Once`, got `std::option::IntoIter` | note: previous use here - --> $DIR/generic_different_defining_uses.rs:7:1 + --> $DIR/generic_different_defining_uses.rs:8:5 | -LL | fn my_iter(t: T) -> MyIter { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | std::iter::once(t) + | ^^^^^^^^^^^^^^^^^^ error: aborting due to previous error diff --git a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use3.rs b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use3.rs index c95692182c2..7747626d96d 100644 --- a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use3.rs +++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use3.rs @@ -13,6 +13,6 @@ fn two(t: T, _: U) -> Two { } fn three(_: T, u: U) -> Two { - //~^ ERROR concrete type differs from previous defining opaque type use u + //~^ ERROR concrete type differs from previous defining opaque type use } diff --git a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use3.stderr b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use3.stderr index e5a70fa8ce5..88c450704bf 100644 --- a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use3.stderr +++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use3.stderr @@ -1,14 +1,14 @@ error: concrete type differs from previous defining opaque type use - --> $DIR/generic_duplicate_param_use3.rs:15:1 + --> $DIR/generic_duplicate_param_use3.rs:16:5 | -LL | fn three(_: T, u: U) -> Two { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `T`, got `U` +LL | u + | ^ expected `T`, got `U` | note: previous use here - --> $DIR/generic_duplicate_param_use3.rs:11:1 + --> $DIR/generic_duplicate_param_use3.rs:12:5 | -LL | fn two(t: T, _: U) -> Two { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | t + | ^ error[E0277]: `T` doesn't implement `Debug` --> $DIR/generic_duplicate_param_use3.rs:8:18 diff --git a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use5.rs b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use5.rs index dd2f202cf5d..03bd00a039d 100644 --- a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use5.rs +++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use5.rs @@ -14,6 +14,6 @@ fn two(t: T, u: U) -> Two { } fn three(t: T, u: U) -> Two { - //~^ concrete type differs from previous (u, t) + //~^ concrete type differs from previous } diff --git a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use5.stderr b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use5.stderr index 6cc6b35668c..d46a3ebe175 100644 --- a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use5.stderr +++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use5.stderr @@ -1,14 +1,14 @@ error: concrete type differs from previous defining opaque type use - --> $DIR/generic_duplicate_param_use5.rs:16:1 + --> $DIR/generic_duplicate_param_use5.rs:17:5 | -LL | fn three(t: T, u: U) -> Two { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `(T, U)`, got `(U, T)` +LL | (u, t) + | ^^^^^^ expected `(T, U)`, got `(U, T)` | note: previous use here - --> $DIR/generic_duplicate_param_use5.rs:12:1 + --> $DIR/generic_duplicate_param_use5.rs:13:5 | -LL | fn two(t: T, u: U) -> Two { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | (t, u) + | ^^^^^^ error[E0277]: `T` doesn't implement `Debug` --> $DIR/generic_duplicate_param_use5.rs:8:18 diff --git a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use6.rs b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use6.rs index d54d3cd62e0..a8c801dc887 100644 --- a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use6.rs +++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use6.rs @@ -13,6 +13,6 @@ fn two(t: T, u: U) -> Two { } fn three(t: T, u: U) -> Two { - //~^ ERROR concrete type differs from previous (u, t) + //~^ ERROR concrete type differs from previous } diff --git a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use6.stderr b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use6.stderr index e7520988e34..7e89b574b5c 100644 --- a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use6.stderr +++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use6.stderr @@ -1,14 +1,14 @@ error: concrete type differs from previous defining opaque type use - --> $DIR/generic_duplicate_param_use6.rs:15:1 + --> $DIR/generic_duplicate_param_use6.rs:16:5 | -LL | fn three(t: T, u: U) -> Two { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `(T, T)`, got `(U, T)` +LL | (u, t) + | ^^^^^^ expected `(T, T)`, got `(U, T)` | note: previous use here - --> $DIR/generic_duplicate_param_use6.rs:11:1 + --> $DIR/generic_duplicate_param_use6.rs:12:5 | -LL | fn two(t: T, u: U) -> Two { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | (t, t) + | ^^^^^^ error[E0277]: `T` doesn't implement `Debug` --> $DIR/generic_duplicate_param_use6.rs:8:18 diff --git a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use8.rs b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use8.rs index 4a723b64cdc..57527e758db 100644 --- a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use8.rs +++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use8.rs @@ -12,6 +12,6 @@ fn two(t: T, _: U) -> Two { } fn three(_: T, u: U) -> Two { - //~^ concrete type differs from previous (u, 4u32) + //~^ concrete type differs from previous } diff --git a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use8.stderr b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use8.stderr index 44bdbdc95cc..1a6ec3aec14 100644 --- a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use8.stderr +++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use8.stderr @@ -1,14 +1,14 @@ error: concrete type differs from previous defining opaque type use - --> $DIR/generic_duplicate_param_use8.rs:14:1 + --> $DIR/generic_duplicate_param_use8.rs:15:5 | -LL | fn three(_: T, u: U) -> Two { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `(T, u32)`, got `(U, u32)` +LL | (u, 4u32) + | ^^^^^^^^^ expected `(T, u32)`, got `(U, u32)` | note: previous use here - --> $DIR/generic_duplicate_param_use8.rs:10:1 + --> $DIR/generic_duplicate_param_use8.rs:11:5 | -LL | fn two(t: T, _: U) -> Two { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | (t, 4u32) + | ^^^^^^^^^ error[E0277]: `T` doesn't implement `Debug` --> $DIR/generic_duplicate_param_use8.rs:7:18 diff --git a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use9.rs b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use9.rs index 4baf198b12f..5878ad92698 100644 --- a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use9.rs +++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use9.rs @@ -19,5 +19,5 @@ fn two(t: T, u: U) -> Two { } fn three(t: T, u: U) -> Two { - (t, u, 42) //~^ ERROR concrete type differs from previous + (t, u, 42) //~ ERROR concrete type differs from previous } diff --git a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use9.stderr b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use9.stderr index 43471f980b2..ef7573246af 100644 --- a/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use9.stderr +++ b/src/test/ui/type-alias-impl-trait/generic_duplicate_param_use9.stderr @@ -1,14 +1,14 @@ error: concrete type differs from previous defining opaque type use - --> $DIR/generic_duplicate_param_use9.rs:21:1 + --> $DIR/generic_duplicate_param_use9.rs:22:5 | -LL | fn three(t: T, u: U) -> Two { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `(A, B, ::Bar)`, got `(A, B, i32)` +LL | (t, u, 42) + | ^^^^^^^^^^ expected `(A, B, ::Bar)`, got `(A, B, i32)` | note: previous use here - --> $DIR/generic_duplicate_param_use9.rs:17:1 + --> $DIR/generic_duplicate_param_use9.rs:18:5 | -LL | fn two(t: T, u: U) -> Two { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | (t, u, T::BAR) + | ^^^^^^^^^^^^^^ error[E0277]: the trait bound `A: Foo` is not satisfied --> $DIR/generic_duplicate_param_use9.rs:7:18 diff --git a/src/test/ui/type-alias-impl-trait/issue-52843-closure-constrain.stderr b/src/test/ui/type-alias-impl-trait/issue-52843-closure-constrain.stderr index d82050e263e..4c5fd22556a 100644 --- a/src/test/ui/type-alias-impl-trait/issue-52843-closure-constrain.stderr +++ b/src/test/ui/type-alias-impl-trait/issue-52843-closure-constrain.stderr @@ -1,14 +1,14 @@ error: concrete type differs from previous defining opaque type use - --> $DIR/issue-52843-closure-constrain.rs:10:16 + --> $DIR/issue-52843-closure-constrain.rs:10:31 | LL | let null = || -> Opaque { 0 }; - | ^^^^^^^^^^^^^^^^^^ expected `String`, got `i32` + | ^ expected `String`, got `i32` | note: previous use here - --> $DIR/issue-52843-closure-constrain.rs:9:5 + --> $DIR/issue-52843-closure-constrain.rs:9:30 | LL | fn _unused() -> Opaque { String::new() } - | ^^^^^^^^^^^^^^^^^^^^^^ + | ^^^^^^^^^^^^^ error: aborting due to previous error diff --git a/src/test/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn-infer.rs b/src/test/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn-infer.rs index 08cb48ccf30..b887fcf3083 100644 --- a/src/test/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn-infer.rs +++ b/src/test/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn-infer.rs @@ -7,7 +7,7 @@ type Y = impl std::fmt::Debug; fn g() -> (Y, Y) { - (42_i64, 60) //~^ ERROR concrete type differs from previous defining opaque type use + (42_i64, 60) //~ ERROR concrete type differs from previous defining opaque type use } fn main() {} diff --git a/src/test/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn-infer.stderr b/src/test/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn-infer.stderr index 3f57612684e..e3709d822ff 100644 --- a/src/test/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn-infer.stderr +++ b/src/test/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn-infer.stderr @@ -1,14 +1,14 @@ error: concrete type differs from previous defining opaque type use - --> $DIR/multiple-def-uses-in-one-fn-infer.rs:9:1 + --> $DIR/multiple-def-uses-in-one-fn-infer.rs:10:5 | -LL | fn g() -> (Y, Y) { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `i64`, got `i32` +LL | (42_i64, 60) + | ^^^^^^^^^^^^ expected `i64`, got `i32` | note: previous use here - --> $DIR/multiple-def-uses-in-one-fn-infer.rs:9:1 + --> $DIR/multiple-def-uses-in-one-fn-infer.rs:10:5 | -LL | fn g() -> (Y, Y) { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | (42_i64, 60) + | ^^^^^^^^^^^^ error: aborting due to previous error diff --git a/src/test/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn-lifetimes.rs b/src/test/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn-lifetimes.rs index f39bf4aeb29..3f122f10609 100644 --- a/src/test/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn-lifetimes.rs +++ b/src/test/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn-lifetimes.rs @@ -3,7 +3,7 @@ type Foo<'a, 'b> = impl std::fmt::Debug; fn foo<'x, 'y>(i: &'x i32, j: &'y i32) -> (Foo<'x, 'y>, Foo<'y, 'x>) { - (i, i) //~^ ERROR concrete type differs from previous + (i, i) //~ ERROR concrete type differs from previous } fn main() {} diff --git a/src/test/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn-lifetimes.stderr b/src/test/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn-lifetimes.stderr index 49d08dda9f9..ed2e48e4aff 100644 --- a/src/test/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn-lifetimes.stderr +++ b/src/test/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn-lifetimes.stderr @@ -1,14 +1,14 @@ error: concrete type differs from previous defining opaque type use - --> $DIR/multiple-def-uses-in-one-fn-lifetimes.rs:5:1 + --> $DIR/multiple-def-uses-in-one-fn-lifetimes.rs:6:5 | -LL | fn foo<'x, 'y>(i: &'x i32, j: &'y i32) -> (Foo<'x, 'y>, Foo<'y, 'x>) { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `&'a i32`, got `&'b i32` +LL | (i, i) + | ^^^^^^ expected `&'a i32`, got `&'b i32` | note: previous use here - --> $DIR/multiple-def-uses-in-one-fn-lifetimes.rs:5:1 + --> $DIR/multiple-def-uses-in-one-fn-lifetimes.rs:6:5 | -LL | fn foo<'x, 'y>(i: &'x i32, j: &'y i32) -> (Foo<'x, 'y>, Foo<'y, 'x>) { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | (i, i) + | ^^^^^^ error: aborting due to previous error diff --git a/src/test/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn2.rs b/src/test/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn2.rs index 06e1990fd7f..14510a5294e 100644 --- a/src/test/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn2.rs +++ b/src/test/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn2.rs @@ -7,8 +7,8 @@ type X = impl ToString; fn f(a: A, b: B) -> (X, X) { - //~^ ERROR concrete type differs from previous defining opaque type (a.clone(), a) + //~^ ERROR concrete type differs from previous defining opaque type } fn main() { diff --git a/src/test/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn2.stderr b/src/test/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn2.stderr index 52b0462de98..de3f8700708 100644 --- a/src/test/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn2.stderr +++ b/src/test/ui/type-alias-impl-trait/multiple-def-uses-in-one-fn2.stderr @@ -1,14 +1,14 @@ error: concrete type differs from previous defining opaque type use - --> $DIR/multiple-def-uses-in-one-fn2.rs:9:1 + --> $DIR/multiple-def-uses-in-one-fn2.rs:10:5 | -LL | fn f(a: A, b: B) -> (X, X) { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `A`, got `B` +LL | (a.clone(), a) + | ^^^^^^^^^^^^^^ expected `A`, got `B` | note: previous use here - --> $DIR/multiple-def-uses-in-one-fn2.rs:9:1 + --> $DIR/multiple-def-uses-in-one-fn2.rs:10:5 | -LL | fn f(a: A, b: B) -> (X, X) { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | (a.clone(), a) + | ^^^^^^^^^^^^^^ error: aborting due to previous error diff --git a/src/test/ui/type-alias-impl-trait/not_a_defining_use.rs b/src/test/ui/type-alias-impl-trait/not_a_defining_use.rs index 5b332b8cb6b..289784ce747 100644 --- a/src/test/ui/type-alias-impl-trait/not_a_defining_use.rs +++ b/src/test/ui/type-alias-impl-trait/not_a_defining_use.rs @@ -22,8 +22,8 @@ impl Bar for u32 { } fn four(t: T) -> Two { - //~^ ERROR concrete type differs from previous (t, ::FOO) + //~^ ERROR concrete type differs from previous } fn is_sync() {} diff --git a/src/test/ui/type-alias-impl-trait/not_a_defining_use.stderr b/src/test/ui/type-alias-impl-trait/not_a_defining_use.stderr index f946dc48a4b..6068cfeb51e 100644 --- a/src/test/ui/type-alias-impl-trait/not_a_defining_use.stderr +++ b/src/test/ui/type-alias-impl-trait/not_a_defining_use.stderr @@ -1,14 +1,14 @@ error: concrete type differs from previous defining opaque type use - --> $DIR/not_a_defining_use.rs:24:1 + --> $DIR/not_a_defining_use.rs:25:5 | -LL | fn four(t: T) -> Two { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `(T, i8)`, got `(T, ::Blub)` +LL | (t, ::FOO) + | ^^^^^^^^^^^^^^^^^^^^ expected `(T, i8)`, got `(T, ::Blub)` | note: previous use here - --> $DIR/not_a_defining_use.rs:10:1 + --> $DIR/not_a_defining_use.rs:11:5 | -LL | fn three(t: T) -> Two { - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +LL | (t, 5i8) + | ^^^^^^^^ error[E0277]: `T` doesn't implement `Debug` --> $DIR/not_a_defining_use.rs:7:18