From f78cbce6484b76886e5849e8f0c5372cba5223fe Mon Sep 17 00:00:00 2001 From: Frank King Date: Sun, 1 Feb 2026 10:13:36 +0800 Subject: [PATCH 01/20] refactor: remove `Adjust::ReborrowPin` --- .../rustc_hir_typeck/src/expr_use_visitor.rs | 13 +--- .../rustc_hir_typeck/src/fn_ctxt/_impl.rs | 4 -- .../rustc_hir_typeck/src/method/confirm.rs | 11 +++- compiler/rustc_lint/src/autorefs.rs | 1 - compiler/rustc_middle/src/ty/adjustment.rs | 4 -- compiler/rustc_mir_build/src/thir/cx/expr.rs | 62 ------------------- 6 files changed, 9 insertions(+), 86 deletions(-) diff --git a/compiler/rustc_hir_typeck/src/expr_use_visitor.rs b/compiler/rustc_hir_typeck/src/expr_use_visitor.rs index b6dfda33142c5..9587b774c4ff2 100644 --- a/compiler/rustc_hir_typeck/src/expr_use_visitor.rs +++ b/compiler/rustc_hir_typeck/src/expr_use_visitor.rs @@ -751,16 +751,6 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx adjustment::Adjust::Borrow(ref autoref) => { self.walk_autoref(expr, &place_with_id, autoref); } - - adjustment::Adjust::ReborrowPin(mutbl) => { - // Reborrowing a Pin is like a combinations of a deref and a borrow, so we do - // both. - let bk = match mutbl { - ty::Mutability::Not => ty::BorrowKind::Immutable, - ty::Mutability::Mut => ty::BorrowKind::Mutable, - }; - self.delegate.borrow_mut().borrow(&place_with_id, place_with_id.hir_id, bk); - } } place_with_id = self.cat_expr_adjusted(expr, place_with_id, adjustment)?; } @@ -1292,8 +1282,7 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx adjustment::Adjust::NeverToAny | adjustment::Adjust::Pointer(_) - | adjustment::Adjust::Borrow(_) - | adjustment::Adjust::ReborrowPin(..) => { + | adjustment::Adjust::Borrow(_) => { // Result is an rvalue. Ok(self.cat_rvalue(expr.hir_id, target)) } diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs index f817ca8421473..d50ac8dbaa742 100644 --- a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs +++ b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs @@ -337,10 +337,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { Adjust::Pointer(_pointer_coercion) => { // FIXME(const_trait_impl): We should probably enforce these. } - Adjust::ReborrowPin(_mutability) => { - // FIXME(const_trait_impl): We could enforce these; they correspond to - // `&mut T: DerefMut` tho, so it's kinda moot. - } Adjust::Borrow(_) => { // No effects to enforce here. } diff --git a/compiler/rustc_hir_typeck/src/method/confirm.rs b/compiler/rustc_hir_typeck/src/method/confirm.rs index 608bc7dffd9c0..add67bd826b1c 100644 --- a/compiler/rustc_hir_typeck/src/method/confirm.rs +++ b/compiler/rustc_hir_typeck/src/method/confirm.rs @@ -18,7 +18,8 @@ use rustc_lint::builtin::{ }; use rustc_middle::traits::ObligationCauseCode; use rustc_middle::ty::adjustment::{ - Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability, PointerCoercion, + Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability, DerefAdjustKind, + PointerCoercion, }; use rustc_middle::ty::{ self, AssocContainer, GenericArgs, GenericArgsRef, GenericParamDefKind, Ty, TyCtxt, @@ -243,12 +244,16 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> { ty::Ref(_, ty, _) => *ty, _ => bug!("Expected a reference type for argument to Pin"), }; + adjustments.push(Adjustment { + kind: Adjust::Deref(DerefAdjustKind::Pin), + target: inner_ty, + }); Ty::new_pinned_ref(self.tcx, region, inner_ty, mutbl) } _ => bug!("Cannot adjust receiver type for reborrowing pin of {target:?}"), }; - - adjustments.push(Adjustment { kind: Adjust::ReborrowPin(mutbl), target }); + adjustments + .push(Adjustment { kind: Adjust::Borrow(AutoBorrow::Pin(mutbl)), target }); } None => {} } diff --git a/compiler/rustc_lint/src/autorefs.rs b/compiler/rustc_lint/src/autorefs.rs index 910a2918f9f71..9a374488ab6fa 100644 --- a/compiler/rustc_lint/src/autorefs.rs +++ b/compiler/rustc_lint/src/autorefs.rs @@ -172,7 +172,6 @@ fn has_implicit_borrow(Adjustment { kind, .. }: &Adjustment<'_>) -> Option<(Muta &Adjust::Borrow(AutoBorrow::Ref(mutbl)) => Some((mutbl.into(), false)), Adjust::NeverToAny | Adjust::Pointer(..) - | Adjust::ReborrowPin(..) | Adjust::Deref(DerefAdjustKind::Builtin | DerefAdjustKind::Pin) | Adjust::Borrow(AutoBorrow::RawPtr(..) | AutoBorrow::Pin(..)) => None, } diff --git a/compiler/rustc_middle/src/ty/adjustment.rs b/compiler/rustc_middle/src/ty/adjustment.rs index 58687be7440b5..3802bde088a54 100644 --- a/compiler/rustc_middle/src/ty/adjustment.rs +++ b/compiler/rustc_middle/src/ty/adjustment.rs @@ -103,10 +103,6 @@ pub enum Adjust { Borrow(AutoBorrow), Pointer(PointerCoercion), - - /// Take a pinned reference and reborrow as a `Pin<&mut T>` or `Pin<&T>`. - // FIXME(pin_ergonomics): This can be replaced with a `Deref(Pin)` followed by a `Borrow(Pin)` - ReborrowPin(hir::Mutability), } #[derive(Copy, Clone, Debug, TyEncodable, TyDecodable, HashStable, TypeFoldable, TypeVisitable)] diff --git a/compiler/rustc_mir_build/src/thir/cx/expr.rs b/compiler/rustc_mir_build/src/thir/cx/expr.rs index c646b0fc45ea1..21d1551af6a5b 100644 --- a/compiler/rustc_mir_build/src/thir/cx/expr.rs +++ b/compiler/rustc_mir_build/src/thir/cx/expr.rs @@ -218,68 +218,6 @@ impl<'tcx> ThirBuildCx<'tcx> { base: AdtExprBase::None, })); - debug!(?kind); - kind - } - Adjust::ReborrowPin(mutbl) => { - debug!("apply ReborrowPin adjustment"); - // Rewrite `$expr` as `Pin { __pointer: &(mut)? *($expr).__pointer }` - - // We'll need these types later on - let pin_ty_args = match expr.ty.kind() { - ty::Adt(_, args) => args, - _ => bug!("ReborrowPin with non-Pin type"), - }; - let pin_ty = pin_ty_args.iter().next().unwrap().expect_ty(); - let ptr_target_ty = match pin_ty.kind() { - ty::Ref(_, ty, _) => *ty, - _ => bug!("ReborrowPin with non-Ref type"), - }; - - // pointer = ($expr).__pointer - let pointer_target = ExprKind::Field { - lhs: self.thir.exprs.push(expr), - variant_index: FIRST_VARIANT, - name: FieldIdx::ZERO, - }; - let arg = Expr { temp_scope_id, ty: pin_ty, span, kind: pointer_target }; - let arg = self.thir.exprs.push(arg); - - // arg = *pointer - let expr = ExprKind::Deref { arg }; - let arg = self.thir.exprs.push(Expr { - temp_scope_id, - ty: ptr_target_ty, - span, - kind: expr, - }); - - // expr = &mut target - let borrow_kind = match mutbl { - hir::Mutability::Mut => BorrowKind::Mut { kind: mir::MutBorrowKind::Default }, - hir::Mutability::Not => BorrowKind::Shared, - }; - let new_pin_target = - Ty::new_ref(self.tcx, self.tcx.lifetimes.re_erased, ptr_target_ty, mutbl); - let expr = self.thir.exprs.push(Expr { - temp_scope_id, - ty: new_pin_target, - span, - kind: ExprKind::Borrow { borrow_kind, arg }, - }); - - // kind = Pin { __pointer: pointer } - let pin_did = self.tcx.require_lang_item(rustc_hir::LangItem::Pin, span); - let args = self.tcx.mk_args(&[new_pin_target.into()]); - let kind = ExprKind::Adt(Box::new(AdtExpr { - adt_def: self.tcx.adt_def(pin_did), - variant_index: FIRST_VARIANT, - args, - fields: Box::new([FieldExpr { name: FieldIdx::ZERO, expr }]), - user_ty: None, - base: AdtExprBase::None, - })); - debug!(?kind); kind } From 69d9576b37dc62b9af763204dd7df8fff7935efe Mon Sep 17 00:00:00 2001 From: randomicon00 <20146907+randomicon00@users.noreply.github.com> Date: Mon, 16 Mar 2026 22:09:53 -0400 Subject: [PATCH 02/20] refactor: move doc(rust_logo) check to parser --- .../rustc_attr_parsing/src/attributes/doc.rs | 23 ++++++++++++++++++- compiler/rustc_passes/src/check_attr.rs | 15 ++---------- 2 files changed, 24 insertions(+), 14 deletions(-) diff --git a/compiler/rustc_attr_parsing/src/attributes/doc.rs b/compiler/rustc_attr_parsing/src/attributes/doc.rs index f8968639f98c2..3a8de4f1a3c21 100644 --- a/compiler/rustc_attr_parsing/src/attributes/doc.rs +++ b/compiler/rustc_attr_parsing/src/attributes/doc.rs @@ -1,10 +1,12 @@ use rustc_ast::ast::{AttrStyle, LitKind, MetaItemLit}; +use rustc_errors::msg; use rustc_feature::template; use rustc_hir::Target; use rustc_hir::attrs::{ AttributeKind, CfgEntry, CfgHideShow, CfgInfo, DocAttribute, DocInline, HideOrShow, }; use rustc_hir::lints::AttributeLintKind; +use rustc_session::parse::feature_err; use rustc_span::{Span, Symbol, edition, sym}; use thin_vec::ThinVec; @@ -553,7 +555,26 @@ impl DocParser { ), Some(sym::fake_variadic) => no_args_and_not_crate_level!(fake_variadic), Some(sym::search_unbox) => no_args_and_not_crate_level!(search_unbox), - Some(sym::rust_logo) => no_args_and_crate_level!(rust_logo), + Some(sym::rust_logo) => { + if let Err(span) = args.no_args() { + expected_no_args(cx, span); + return; + } + let span = path.span(); + if !check_attr_crate_level(cx, span) { + return; + } + if !cx.features().rustdoc_internals() { + feature_err( + cx.sess(), + sym::rustdoc_internals, + span, + msg!("the `#[doc(rust_logo)]` attribute is used for Rust branding"), + ) + .emit(); + } + self.attribute.rust_logo = Some(span); + } Some(sym::auto_cfg) => self.parse_auto_cfg(cx, path, args), Some(sym::test) => { let Some(list) = args.list() else { diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs index bec6ab7e83551..5b6b214a09abe 100644 --- a/compiler/rustc_passes/src/check_attr.rs +++ b/compiler/rustc_passes/src/check_attr.rs @@ -1145,7 +1145,8 @@ impl<'tcx> CheckAttrVisitor<'tcx> { html_no_source: _, // already checked in attr_parsing issue_tracker_base_url: _, - rust_logo, + // already checked in attr_parsing + rust_logo: _, // allowed anywhere test_attrs: _, // already checked in attr_parsing @@ -1174,18 +1175,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> { self.check_doc_inline(hir_id, target, inline); - if let Some(span) = rust_logo - && !self.tcx.features().rustdoc_internals() - { - feature_err( - &self.tcx.sess, - sym::rustdoc_internals, - *span, - msg!("the `#[doc(rust_logo)]` attribute is used for Rust branding"), - ) - .emit(); - } - if let Some(span) = masked { self.check_doc_masked(*span, hir_id, target); } From 48987fdba7ccb3815bfa05d239f0f7b0deab1c0a Mon Sep 17 00:00:00 2001 From: randomicon00 <20146907+randomicon00@users.noreply.github.com> Date: Tue, 17 Mar 2026 21:06:40 -0400 Subject: [PATCH 03/20] refactor: reuse doc attr helper for rust_logo --- .../rustc_attr_parsing/src/attributes/doc.rs | 23 ++++++++----------- 1 file changed, 9 insertions(+), 14 deletions(-) diff --git a/compiler/rustc_attr_parsing/src/attributes/doc.rs b/compiler/rustc_attr_parsing/src/attributes/doc.rs index 3a8de4f1a3c21..099a75e11f3af 100644 --- a/compiler/rustc_attr_parsing/src/attributes/doc.rs +++ b/compiler/rustc_attr_parsing/src/attributes/doc.rs @@ -483,15 +483,19 @@ impl DocParser { } macro_rules! no_args_and_crate_level { ($ident: ident) => {{ + no_args_and_crate_level!($ident, |span| {}); + }}; + ($ident: ident, |$span:ident| $extra_validation:block) => {{ if let Err(span) = args.no_args() { expected_no_args(cx, span); return; } - let span = path.span(); - if !check_attr_crate_level(cx, span) { + let $span = path.span(); + if !check_attr_crate_level(cx, $span) { return; } - self.attribute.$ident = Some(span); + $extra_validation + self.attribute.$ident = Some($span); }}; } macro_rules! string_arg_and_crate_level { @@ -555,15 +559,7 @@ impl DocParser { ), Some(sym::fake_variadic) => no_args_and_not_crate_level!(fake_variadic), Some(sym::search_unbox) => no_args_and_not_crate_level!(search_unbox), - Some(sym::rust_logo) => { - if let Err(span) = args.no_args() { - expected_no_args(cx, span); - return; - } - let span = path.span(); - if !check_attr_crate_level(cx, span) { - return; - } + Some(sym::rust_logo) => no_args_and_crate_level!(rust_logo, |span| { if !cx.features().rustdoc_internals() { feature_err( cx.sess(), @@ -573,8 +569,7 @@ impl DocParser { ) .emit(); } - self.attribute.rust_logo = Some(span); - } + }), Some(sym::auto_cfg) => self.parse_auto_cfg(cx, path, args), Some(sym::test) => { let Some(list) = args.list() else { From de1b0ac73a5701f1c3916e27938df22139e7b939 Mon Sep 17 00:00:00 2001 From: Embers-of-the-Fire Date: Fri, 20 Mar 2026 18:02:43 +0800 Subject: [PATCH 04/20] fix: guard paren-sugar pretty-printing on short trait args --- compiler/rustc_middle/src/ty/print/pretty.rs | 3 ++- .../paren-sugar-non-fn-trait-issue-153855.rs | 12 ++++++++++ ...ren-sugar-non-fn-trait-issue-153855.stderr | 15 +++++++++++++ ...en-sugar-non-fn-trait-ufcs-issue-153855.rs | 16 ++++++++++++++ ...ugar-non-fn-trait-ufcs-issue-153855.stderr | 22 +++++++++++++++++++ 5 files changed, 67 insertions(+), 1 deletion(-) create mode 100644 tests/ui/unboxed-closures/paren-sugar-non-fn-trait-issue-153855.rs create mode 100644 tests/ui/unboxed-closures/paren-sugar-non-fn-trait-issue-153855.stderr create mode 100644 tests/ui/unboxed-closures/paren-sugar-non-fn-trait-ufcs-issue-153855.rs create mode 100644 tests/ui/unboxed-closures/paren-sugar-non-fn-trait-ufcs-issue-153855.stderr diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs index 2c14c37609d41..deef3065c3455 100644 --- a/compiler/rustc_middle/src/ty/print/pretty.rs +++ b/compiler/rustc_middle/src/ty/print/pretty.rs @@ -3314,7 +3314,8 @@ define_print_and_forward_display! { TraitRefPrintSugared<'tcx> { if !with_reduced_queries() && p.tcx().trait_def(self.0.def_id).paren_sugar - && let ty::Tuple(args) = self.0.args.type_at(1).kind() + && let Some(args_ty) = self.0.args.get(1).and_then(|arg| arg.as_type()) + && let ty::Tuple(args) = args_ty.kind() { write!(p, "{}(", p.tcx().item_name(self.0.def_id))?; for (i, arg) in args.iter().enumerate() { diff --git a/tests/ui/unboxed-closures/paren-sugar-non-fn-trait-issue-153855.rs b/tests/ui/unboxed-closures/paren-sugar-non-fn-trait-issue-153855.rs new file mode 100644 index 0000000000000..40816c39e6683 --- /dev/null +++ b/tests/ui/unboxed-closures/paren-sugar-non-fn-trait-issue-153855.rs @@ -0,0 +1,12 @@ +#![feature(rustc_attrs, unboxed_closures)] +#![allow(internal_features)] + +#[rustc_paren_sugar] +trait Tr { + fn method(); +} + +fn main() { + ::method(); + //~^ ERROR the trait bound `u8: Tr` is not satisfied +} diff --git a/tests/ui/unboxed-closures/paren-sugar-non-fn-trait-issue-153855.stderr b/tests/ui/unboxed-closures/paren-sugar-non-fn-trait-issue-153855.stderr new file mode 100644 index 0000000000000..99699d8cb482e --- /dev/null +++ b/tests/ui/unboxed-closures/paren-sugar-non-fn-trait-issue-153855.stderr @@ -0,0 +1,15 @@ +error[E0277]: the trait bound `u8: Tr` is not satisfied + --> $DIR/paren-sugar-non-fn-trait-issue-153855.rs:10:6 + | +LL | ::method(); + | ^^ the trait `Tr` is not implemented for `u8` + | +help: this trait has no implementations, consider adding one + --> $DIR/paren-sugar-non-fn-trait-issue-153855.rs:5:1 + | +LL | trait Tr { + | ^^^^^^^^ + +error: aborting due to 1 previous error + +For more information about this error, try `rustc --explain E0277`. diff --git a/tests/ui/unboxed-closures/paren-sugar-non-fn-trait-ufcs-issue-153855.rs b/tests/ui/unboxed-closures/paren-sugar-non-fn-trait-ufcs-issue-153855.rs new file mode 100644 index 0000000000000..c49a2fe34c78d --- /dev/null +++ b/tests/ui/unboxed-closures/paren-sugar-non-fn-trait-ufcs-issue-153855.rs @@ -0,0 +1,16 @@ +#![feature(rustc_attrs, unboxed_closures)] +#![allow(internal_features)] + +// Regression test for #153855: diagnostics should not ICE when a +// `#[rustc_paren_sugar]` trait is used with parenthesized syntax but does not +// have an `Fn`-family generic layout. +#[rustc_paren_sugar] +trait Tr<'a, 'b, T> { + fn method() {} +} + +fn main() { + ::method; + //~^ ERROR associated item constraints are not allowed here + //~| ERROR the trait bound `u8: Tr<'_, '_, (&u8,)>` is not satisfied +} diff --git a/tests/ui/unboxed-closures/paren-sugar-non-fn-trait-ufcs-issue-153855.stderr b/tests/ui/unboxed-closures/paren-sugar-non-fn-trait-ufcs-issue-153855.stderr new file mode 100644 index 0000000000000..c4ce9047cd30b --- /dev/null +++ b/tests/ui/unboxed-closures/paren-sugar-non-fn-trait-ufcs-issue-153855.stderr @@ -0,0 +1,22 @@ +error[E0229]: associated item constraints are not allowed here + --> $DIR/paren-sugar-non-fn-trait-ufcs-issue-153855.rs:13:12 + | +LL | ::method; + | ^^^^^^^ associated item constraint not allowed here + +error[E0277]: the trait bound `u8: Tr<'_, '_, (&u8,)>` is not satisfied + --> $DIR/paren-sugar-non-fn-trait-ufcs-issue-153855.rs:13:6 + | +LL | ::method; + | ^^ the trait `Tr<'_, '_, (&u8,)>` is not implemented for `u8` + | +help: this trait has no implementations, consider adding one + --> $DIR/paren-sugar-non-fn-trait-ufcs-issue-153855.rs:8:1 + | +LL | trait Tr<'a, 'b, T> { + | ^^^^^^^^^^^^^^^^^^^ + +error: aborting due to 2 previous errors + +Some errors have detailed explanations: E0229, E0277. +For more information about an error, try `rustc --explain E0229`. From 576a7277cbea967c5784750f2851099b3c7a9732 Mon Sep 17 00:00:00 2001 From: Daria Sukhonina Date: Thu, 12 Mar 2026 13:25:40 +0300 Subject: [PATCH 05/20] Take first task group for further execution --- compiler/rustc_data_structures/src/sync/parallel.rs | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/compiler/rustc_data_structures/src/sync/parallel.rs b/compiler/rustc_data_structures/src/sync/parallel.rs index b112ecc2fbad1..966c34f7e1525 100644 --- a/compiler/rustc_data_structures/src/sync/parallel.rs +++ b/compiler/rustc_data_structures/src/sync/parallel.rs @@ -145,7 +145,9 @@ fn par_slice( const MAX_GROUP_COUNT: usize = 128; let group_size = items.len().div_ceil(MAX_GROUP_COUNT); - let groups = items.chunks_mut(group_size); + let mut groups = items.chunks_mut(group_size); + + let Some(first_group) = groups.next() else { return }; // Reverse the order of the later functions since Rayon executes them in reverse // order when using a single thread. This ensures the execution order matches @@ -159,6 +161,11 @@ fn par_slice( } }); } + + // Run the first function without spawning to avoid overwhelming stealing. + for i in first_group.iter_mut() { + guard.run(|| for_each(i)); + } }); } From 785b5113608a886309962ed836ee7a4bcf13bfaa Mon Sep 17 00:00:00 2001 From: yukang Date: Mon, 30 Mar 2026 10:08:12 +0800 Subject: [PATCH 06/20] fix where clause rustfix suggestion spacing --- .../rustc_ast_passes/src/ast_validation.rs | 20 ++++++++++++------- ...lias-type-where-suggest-issue-153567.fixed | 17 ++++++++++++++++ .../alias-type-where-suggest-issue-153567.rs | 17 ++++++++++++++++ ...ias-type-where-suggest-issue-153567.stderr | 16 +++++++++++++++ ...-clause-placement-assoc-type-in-impl.fixed | 8 ++++---- ...clause-placement-assoc-type-in-impl.stderr | 8 ++++---- ...clause-placement-assoc-type-in-trait.fixed | 4 ++-- ...lause-placement-assoc-type-in-trait.stderr | 4 ++-- 8 files changed, 75 insertions(+), 19 deletions(-) create mode 100644 tests/ui/where-clauses/alias-type-where-suggest-issue-153567.fixed create mode 100644 tests/ui/where-clauses/alias-type-where-suggest-issue-153567.rs create mode 100644 tests/ui/where-clauses/alias-type-where-suggest-issue-153567.stderr diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs index dd14e91435690..d59b148154c93 100644 --- a/compiler/rustc_ast_passes/src/ast_validation.rs +++ b/compiler/rustc_ast_passes/src/ast_validation.rs @@ -173,17 +173,19 @@ impl<'a> AstValidator<'a> { { let mut state = State::new(); + let mut needs_comma = !ty_alias.after_where_clause.predicates.is_empty(); if !ty_alias.after_where_clause.has_where_token { state.space(); state.word_space("where"); + } else if !needs_comma { + state.space(); } - let mut first = ty_alias.after_where_clause.predicates.is_empty(); for p in &ty_alias.generics.where_clause.predicates { - if !first { + if needs_comma { state.word_space(","); } - first = false; + needs_comma = true; state.print_where_predicate(p); } @@ -1832,7 +1834,11 @@ impl<'a> Visitor<'a> for AstValidator<'a> { Some((right, snippet)) } }; - let left_sp = err.span; + let left_sp = self + .sess + .source_map() + .span_extend_prev_while(err.span, char::is_whitespace) + .unwrap_or(err.span); self.lint_buffer.dyn_buffer_lint( DEPRECATED_WHERE_CLAUSE_LOCATION, item.id, @@ -1846,9 +1852,9 @@ impl<'a> Visitor<'a> for AstValidator<'a> { sugg, } } - None => { - errors::DeprecatedWhereClauseLocationSugg::RemoveWhere { span: left_sp } - } + None => errors::DeprecatedWhereClauseLocationSugg::RemoveWhere { + span: err.span, + }, }; errors::DeprecatedWhereClauseLocation { suggestion }.into_diag(dcx, level) }, diff --git a/tests/ui/where-clauses/alias-type-where-suggest-issue-153567.fixed b/tests/ui/where-clauses/alias-type-where-suggest-issue-153567.fixed new file mode 100644 index 0000000000000..01da73716e884 --- /dev/null +++ b/tests/ui/where-clauses/alias-type-where-suggest-issue-153567.fixed @@ -0,0 +1,17 @@ +//@ check-pass +//@ run-rustfix +//@ compile-flags: --force-warn deprecated_where_clause_location + + +#![allow(dead_code)] + +trait Trait { + type Assoc; +} + +impl Trait for i32 { + type Assoc = () where i32: Copy; + //~^ WARNING where clause not allowed here +} + +fn main() {} diff --git a/tests/ui/where-clauses/alias-type-where-suggest-issue-153567.rs b/tests/ui/where-clauses/alias-type-where-suggest-issue-153567.rs new file mode 100644 index 0000000000000..cdee4c753b87d --- /dev/null +++ b/tests/ui/where-clauses/alias-type-where-suggest-issue-153567.rs @@ -0,0 +1,17 @@ +//@ check-pass +//@ run-rustfix +//@ compile-flags: --force-warn deprecated_where_clause_location + + +#![allow(dead_code)] + +trait Trait { + type Assoc; +} + +impl Trait for i32 { + type Assoc where i32: Copy = () where; + //~^ WARNING where clause not allowed here +} + +fn main() {} diff --git a/tests/ui/where-clauses/alias-type-where-suggest-issue-153567.stderr b/tests/ui/where-clauses/alias-type-where-suggest-issue-153567.stderr new file mode 100644 index 0000000000000..d3421505bf5ca --- /dev/null +++ b/tests/ui/where-clauses/alias-type-where-suggest-issue-153567.stderr @@ -0,0 +1,16 @@ +warning: where clause not allowed here + --> $DIR/alias-type-where-suggest-issue-153567.rs:13:16 + | +LL | type Assoc where i32: Copy = () where; + | ^^^^^^^^^^^^^^^ + | + = note: see issue #89122 for more information + = note: requested on the command line with `--force-warn deprecated-where-clause-location` +help: move it to the end of the type declaration + | +LL - type Assoc where i32: Copy = () where; +LL + type Assoc = () where i32: Copy; + | + +warning: 1 warning emitted + diff --git a/tests/ui/where-clauses/where-clause-placement-assoc-type-in-impl.fixed b/tests/ui/where-clauses/where-clause-placement-assoc-type-in-impl.fixed index 9b935b1667878..5f3882ccb412e 100644 --- a/tests/ui/where-clauses/where-clause-placement-assoc-type-in-impl.fixed +++ b/tests/ui/where-clauses/where-clause-placement-assoc-type-in-impl.fixed @@ -14,12 +14,12 @@ trait Trait { impl Trait for u32 { // Not fine, suggests moving. - type Assoc = () where u32: Copy; + type Assoc = () where u32: Copy; //~^ WARNING where clause not allowed here // Not fine, suggests moving `u32: Copy` - type Assoc2 = () where i32: Copy, u32: Copy; + type Assoc2 = () where i32: Copy, u32: Copy; //~^ WARNING where clause not allowed here - type Assoc3 = () where; + type Assoc3 = () where; //~^ WARNING where clause not allowed here } @@ -27,7 +27,7 @@ impl Trait for i32 { // Fine. type Assoc = () where u32: Copy; // Not fine, suggests moving both. - type Assoc2 = () where u32: Copy, i32: Copy; + type Assoc2 = () where u32: Copy, i32: Copy; //~^ WARNING where clause not allowed here type Assoc3 = () where; //~^ WARNING where clause not allowed here diff --git a/tests/ui/where-clauses/where-clause-placement-assoc-type-in-impl.stderr b/tests/ui/where-clauses/where-clause-placement-assoc-type-in-impl.stderr index 5809ff8f80347..f31c8b2dd8219 100644 --- a/tests/ui/where-clauses/where-clause-placement-assoc-type-in-impl.stderr +++ b/tests/ui/where-clauses/where-clause-placement-assoc-type-in-impl.stderr @@ -9,7 +9,7 @@ LL | type Assoc where u32: Copy = (); help: move it to the end of the type declaration | LL - type Assoc where u32: Copy = (); -LL + type Assoc = () where u32: Copy; +LL + type Assoc = () where u32: Copy; | warning: where clause not allowed here @@ -22,7 +22,7 @@ LL | type Assoc2 where u32: Copy = () where i32: Copy; help: move it to the end of the type declaration | LL - type Assoc2 where u32: Copy = () where i32: Copy; -LL + type Assoc2 = () where i32: Copy, u32: Copy; +LL + type Assoc2 = () where i32: Copy, u32: Copy; | warning: where clause not allowed here @@ -35,7 +35,7 @@ LL | type Assoc3 where = (); help: move it to the end of the type declaration | LL - type Assoc3 where = (); -LL + type Assoc3 = () where; +LL + type Assoc3 = () where; | warning: where clause not allowed here @@ -48,7 +48,7 @@ LL | type Assoc2 where u32: Copy, i32: Copy = (); help: move it to the end of the type declaration | LL - type Assoc2 where u32: Copy, i32: Copy = (); -LL + type Assoc2 = () where u32: Copy, i32: Copy; +LL + type Assoc2 = () where u32: Copy, i32: Copy; | warning: where clause not allowed here diff --git a/tests/ui/where-clauses/where-clause-placement-assoc-type-in-trait.fixed b/tests/ui/where-clauses/where-clause-placement-assoc-type-in-trait.fixed index 719f1d2a4c603..02dba8f946d6c 100644 --- a/tests/ui/where-clauses/where-clause-placement-assoc-type-in-trait.fixed +++ b/tests/ui/where-clauses/where-clause-placement-assoc-type-in-trait.fixed @@ -6,10 +6,10 @@ trait Trait { // Not fine, suggests moving. - type Assoc = () where u32: Copy; + type Assoc = () where u32: Copy; //~^ WARNING where clause not allowed here // Not fine, suggests moving `u32: Copy` - type Assoc2 = () where i32: Copy, u32: Copy; + type Assoc2 = () where i32: Copy, u32: Copy; //~^ WARNING where clause not allowed here } diff --git a/tests/ui/where-clauses/where-clause-placement-assoc-type-in-trait.stderr b/tests/ui/where-clauses/where-clause-placement-assoc-type-in-trait.stderr index 9e9967ef7391a..1b7c09897b7b8 100644 --- a/tests/ui/where-clauses/where-clause-placement-assoc-type-in-trait.stderr +++ b/tests/ui/where-clauses/where-clause-placement-assoc-type-in-trait.stderr @@ -9,7 +9,7 @@ LL | type Assoc where u32: Copy = (); help: move it to the end of the type declaration | LL - type Assoc where u32: Copy = (); -LL + type Assoc = () where u32: Copy; +LL + type Assoc = () where u32: Copy; | warning: where clause not allowed here @@ -22,7 +22,7 @@ LL | type Assoc2 where u32: Copy = () where i32: Copy; help: move it to the end of the type declaration | LL - type Assoc2 where u32: Copy = () where i32: Copy; -LL + type Assoc2 = () where i32: Copy, u32: Copy; +LL + type Assoc2 = () where i32: Copy, u32: Copy; | warning: 2 warnings emitted From 17e0cc3ebd6562dde473e49207d1a79901b3fa2c Mon Sep 17 00:00:00 2001 From: James Barford-Evans Date: Mon, 23 Mar 2026 18:09:15 +0000 Subject: [PATCH 07/20] Create `Ty` type alias in `rustc_type_ir` --- .../src/canonical/canonicalizer.rs | 6 +- .../src/canonical/mod.rs | 6 +- .../rustc_next_trait_solver/src/coherence.rs | 29 ++++--- .../rustc_next_trait_solver/src/delegate.rs | 8 +- .../src/placeholder.rs | 2 +- .../rustc_next_trait_solver/src/resolve.rs | 6 +- .../src/solve/assembly/mod.rs | 12 +-- .../src/solve/assembly/structural_traits.rs | 38 ++++---- .../src/solve/effect_goals.rs | 6 +- .../src/solve/eval_ctxt/mod.rs | 28 +++--- .../rustc_next_trait_solver/src/solve/mod.rs | 10 +-- .../src/solve/normalizes_to/mod.rs | 4 +- .../src/solve/trait_goals.rs | 27 +++--- compiler/rustc_type_ir/src/binder.rs | 16 ++-- compiler/rustc_type_ir/src/error.rs | 8 +- compiler/rustc_type_ir/src/fast_reject.rs | 15 ++-- compiler/rustc_type_ir/src/flags.rs | 4 +- compiler/rustc_type_ir/src/fold.rs | 8 +- compiler/rustc_type_ir/src/generic_arg.rs | 6 +- compiler/rustc_type_ir/src/infer_ctxt.rs | 34 +++----- compiler/rustc_type_ir/src/inherent.rs | 36 ++++---- compiler/rustc_type_ir/src/lib.rs | 6 +- compiler/rustc_type_ir/src/outlives.rs | 8 +- compiler/rustc_type_ir/src/predicate.rs | 48 +++++------ compiler/rustc_type_ir/src/predicate_kind.rs | 6 +- compiler/rustc_type_ir/src/relate.rs | 18 ++-- compiler/rustc_type_ir/src/relate/combine.rs | 16 ++-- .../src/relate/solver_relating.rs | 16 ++-- compiler/rustc_type_ir/src/solve/mod.rs | 4 +- compiler/rustc_type_ir/src/sty/mod.rs | 3 + compiler/rustc_type_ir/src/ty_kind.rs | 46 +++++----- compiler/rustc_type_ir/src/ty_kind/closure.rs | 86 +++++++++---------- compiler/rustc_type_ir/src/visit.rs | 8 +- 33 files changed, 292 insertions(+), 282 deletions(-) create mode 100644 compiler/rustc_type_ir/src/sty/mod.rs diff --git a/compiler/rustc_next_trait_solver/src/canonical/canonicalizer.rs b/compiler/rustc_next_trait_solver/src/canonical/canonicalizer.rs index ce2be24adc586..5a0f149fd0550 100644 --- a/compiler/rustc_next_trait_solver/src/canonical/canonicalizer.rs +++ b/compiler/rustc_next_trait_solver/src/canonical/canonicalizer.rs @@ -78,7 +78,7 @@ pub(super) struct Canonicalizer<'a, D: SolverDelegate, I: Interner /// We can simply cache based on the ty itself, because we use /// `ty::BoundVarIndexKind::Canonical`. - cache: HashMap, + cache: HashMap, ty::Ty>, } impl<'a, D: SolverDelegate, I: Interner> Canonicalizer<'a, D, I> { @@ -316,7 +316,7 @@ impl<'a, D: SolverDelegate, I: Interner> Canonicalizer<'a, D, I> { (max_universe, self.variables, var_kinds) } - fn inner_fold_ty(&mut self, t: I::Ty) -> I::Ty { + fn inner_fold_ty(&mut self, t: ty::Ty) -> ty::Ty { let kind = match t.kind() { ty::Infer(i) => match i { ty::TyVar(vid) => { @@ -475,7 +475,7 @@ impl, I: Interner> TypeFolder for Canonicaliz Region::new_canonical_bound(self.cx(), var) } - fn fold_ty(&mut self, t: I::Ty) -> I::Ty { + fn fold_ty(&mut self, t: ty::Ty) -> ty::Ty { if !t.flags().intersects(NEEDS_CANONICAL) { t } else if let Some(&ty) = self.cache.get(&t) { diff --git a/compiler/rustc_next_trait_solver/src/canonical/mod.rs b/compiler/rustc_next_trait_solver/src/canonical/mod.rs index 1f64f09fe787f..cd42bf8b57b60 100644 --- a/compiler/rustc_next_trait_solver/src/canonical/mod.rs +++ b/compiler/rustc_next_trait_solver/src/canonical/mod.rs @@ -16,7 +16,7 @@ use rustc_index::IndexVec; use rustc_type_ir::inherent::*; use rustc_type_ir::relate::solver_relating::RelateExt; use rustc_type_ir::{ - self as ty, Canonical, CanonicalVarKind, CanonicalVarValues, InferCtxtLike, Interner, + self as ty, Canonical, CanonicalVarKind, CanonicalVarValues, InferCtxtLike, Interner, Ty, TypeFoldable, }; use tracing::instrument; @@ -53,7 +53,7 @@ impl ResponseT for inspect::State { pub(super) fn canonicalize_goal( delegate: &D, goal: Goal, - opaque_types: &[(ty::OpaqueTypeKey, I::Ty)], + opaque_types: &[(ty::OpaqueTypeKey, Ty)], ) -> (Vec, CanonicalInput) where D: SolverDelegate, @@ -264,7 +264,7 @@ fn register_region_constraints( fn register_new_opaque_types( delegate: &D, - opaque_types: &[(ty::OpaqueTypeKey, I::Ty)], + opaque_types: &[(ty::OpaqueTypeKey, Ty)], span: I::Span, ) where D: SolverDelegate, diff --git a/compiler/rustc_next_trait_solver/src/coherence.rs b/compiler/rustc_next_trait_solver/src/coherence.rs index c370fd24a1bb3..69cebb0a3dc64 100644 --- a/compiler/rustc_next_trait_solver/src/coherence.rs +++ b/compiler/rustc_next_trait_solver/src/coherence.rs @@ -47,7 +47,7 @@ pub enum Conflict { pub fn trait_ref_is_knowable( infcx: &Infcx, trait_ref: ty::TraitRef, - mut lazily_normalize_ty: impl FnMut(I::Ty) -> Result, + mut lazily_normalize_ty: impl FnMut(ty::Ty) -> Result, E>, ) -> Result, E> where Infcx: InferCtxtLike, @@ -115,14 +115,14 @@ impl From for IsFirstInputType { #[derive_where(Debug; I: Interner, T: Debug)] pub enum OrphanCheckErr { - NonLocalInputType(Vec<(I::Ty, IsFirstInputType)>), + NonLocalInputType(Vec<(ty::Ty, IsFirstInputType)>), UncoveredTyParams(UncoveredTyParams), } #[derive_where(Debug; I: Interner, T: Debug)] pub struct UncoveredTyParams { pub uncovered: T, - pub local_ty: Option, + pub local_ty: Option>, } /// Checks whether a trait-ref is potentially implementable by a crate. @@ -222,8 +222,8 @@ pub fn orphan_check_trait_ref( infcx: &Infcx, trait_ref: ty::TraitRef, in_crate: InCrate, - lazily_normalize_ty: impl FnMut(I::Ty) -> Result, -) -> Result>, E> + lazily_normalize_ty: impl FnMut(ty::Ty) -> Result, E>, +) -> Result>>, E> where Infcx: InferCtxtLike, I: Interner, @@ -262,14 +262,14 @@ struct OrphanChecker<'a, Infcx, I: Interner, F> { lazily_normalize_ty: F, /// Ignore orphan check failures and exclusively search for the first local type. search_first_local_ty: bool, - non_local_tys: Vec<(I::Ty, IsFirstInputType)>, + non_local_tys: Vec<(ty::Ty, IsFirstInputType)>, } impl<'a, Infcx, I, F, E> OrphanChecker<'a, Infcx, I, F> where Infcx: InferCtxtLike, I: Interner, - F: FnOnce(I::Ty) -> Result, + F: FnOnce(ty::Ty) -> Result, E>, { fn new(infcx: &'a Infcx, in_crate: InCrate, lazily_normalize_ty: F) -> Self { OrphanChecker { @@ -282,12 +282,15 @@ where } } - fn found_non_local_ty(&mut self, t: I::Ty) -> ControlFlow> { + fn found_non_local_ty(&mut self, t: ty::Ty) -> ControlFlow> { self.non_local_tys.push((t, self.in_self_ty.into())); ControlFlow::Continue(()) } - fn found_uncovered_ty_param(&mut self, ty: I::Ty) -> ControlFlow> { + fn found_uncovered_ty_param( + &mut self, + ty: ty::Ty, + ) -> ControlFlow> { if self.search_first_local_ty { return ControlFlow::Continue(()); } @@ -305,15 +308,15 @@ where enum OrphanCheckEarlyExit { NormalizationFailure(E), - UncoveredTyParam(I::Ty), - LocalTy(I::Ty), + UncoveredTyParam(ty::Ty), + LocalTy(ty::Ty), } impl<'a, Infcx, I, F, E> TypeVisitor for OrphanChecker<'a, Infcx, I, F> where Infcx: InferCtxtLike, I: Interner, - F: FnMut(I::Ty) -> Result, + F: FnMut(ty::Ty) -> Result, E>, { type Result = ControlFlow>; @@ -321,7 +324,7 @@ where ControlFlow::Continue(()) } - fn visit_ty(&mut self, ty: I::Ty) -> Self::Result { + fn visit_ty(&mut self, ty: ty::Ty) -> Self::Result { let ty = self.infcx.shallow_resolve(ty); let ty = match (self.lazily_normalize_ty)(ty) { Ok(norm_ty) if norm_ty.is_ty_var() => ty, diff --git a/compiler/rustc_next_trait_solver/src/delegate.rs b/compiler/rustc_next_trait_solver/src/delegate.rs index 9d5aa8bc124b6..1714ae3dd6b2e 100644 --- a/compiler/rustc_next_trait_solver/src/delegate.rs +++ b/compiler/rustc_next_trait_solver/src/delegate.rs @@ -1,7 +1,7 @@ use std::ops::Deref; use rustc_type_ir::solve::{Certainty, Goal, NoSolution}; -use rustc_type_ir::{self as ty, InferCtxtLike, Interner, TypeFoldable}; +use rustc_type_ir::{self as ty, InferCtxtLike, Interner, Ty, TypeFoldable}; pub trait SolverDelegate: Deref + Sized { type Infcx: InferCtxtLike; @@ -70,7 +70,7 @@ pub trait SolverDelegate: Deref + Sized { def_id: ::DefId, args: ::GenericArgs, param_env: ::ParamEnv, - hidden_ty: ::Ty, + hidden_ty: Ty, goals: &mut Vec::Predicate>>, ); @@ -86,8 +86,8 @@ pub trait SolverDelegate: Deref + Sized { fn is_transmutable( &self, - src: ::Ty, - dst: ::Ty, + src: Ty, + dst: Ty, assume: ::Const, ) -> Result; } diff --git a/compiler/rustc_next_trait_solver/src/placeholder.rs b/compiler/rustc_next_trait_solver/src/placeholder.rs index 83f3bdf01dc83..fe7521c86e9be 100644 --- a/compiler/rustc_next_trait_solver/src/placeholder.rs +++ b/compiler/rustc_next_trait_solver/src/placeholder.rs @@ -113,7 +113,7 @@ where } } - fn fold_ty(&mut self, t: I::Ty) -> I::Ty { + fn fold_ty(&mut self, t: ty::Ty) -> ty::Ty { match t.kind() { ty::Bound(ty::BoundVarIndexKind::Bound(debruijn), _) if debruijn.as_usize() + 1 diff --git a/compiler/rustc_next_trait_solver/src/resolve.rs b/compiler/rustc_next_trait_solver/src/resolve.rs index c3c57eccd6eff..86bf05bdb57cc 100644 --- a/compiler/rustc_next_trait_solver/src/resolve.rs +++ b/compiler/rustc_next_trait_solver/src/resolve.rs @@ -1,7 +1,7 @@ use rustc_type_ir::data_structures::DelayedMap; use rustc_type_ir::inherent::*; use rustc_type_ir::{ - self as ty, InferCtxtLike, Interner, TypeFoldable, TypeFolder, TypeSuperFoldable, + self as ty, InferCtxtLike, Interner, Ty, TypeFoldable, TypeFolder, TypeSuperFoldable, TypeVisitableExt, }; @@ -19,7 +19,7 @@ where delegate: &'a D, /// We're able to use a cache here as the folder does not have any /// mutable state. - cache: DelayedMap, + cache: DelayedMap, Ty>, } pub fn eager_resolve_vars>( @@ -45,7 +45,7 @@ impl, I: Interner> TypeFolder for EagerResolv self.delegate.cx() } - fn fold_ty(&mut self, t: I::Ty) -> I::Ty { + fn fold_ty(&mut self, t: Ty) -> Ty { match t.kind() { ty::Infer(ty::TyVar(vid)) => { let resolved = self.delegate.opportunistic_resolve_ty_var(vid); diff --git a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs index 32b1e93bf98be..f58318b83625d 100644 --- a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs +++ b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs @@ -46,11 +46,11 @@ where D: SolverDelegate, I: Interner, { - fn self_ty(self) -> I::Ty; + fn self_ty(self) -> ty::Ty; fn trait_ref(self, cx: I) -> ty::TraitRef; - fn with_replaced_self_ty(self, cx: I, self_ty: I::Ty) -> Self; + fn with_replaced_self_ty(self, cx: I, self_ty: ty::Ty) -> Self; fn trait_def_id(self, cx: I) -> I::TraitId; @@ -683,7 +683,7 @@ where // hitting another overflow error something. Add a depth parameter needed later. fn assemble_alias_bound_candidates_recur>( &mut self, - self_ty: I::Ty, + self_ty: ty::Ty, goal: Goal, candidates: &mut Vec>, consider_self_bounds: AliasBoundKind, @@ -1017,13 +1017,13 @@ where struct ReplaceOpaque { cx: I, alias_ty: ty::AliasTy, - self_ty: I::Ty, + self_ty: ty::Ty, } impl TypeFolder for ReplaceOpaque { fn cx(&self) -> I { self.cx } - fn fold_ty(&mut self, ty: I::Ty) -> I::Ty { + fn fold_ty(&mut self, ty: ty::Ty) -> ty::Ty { if let ty::Alias(ty::Opaque, alias_ty) = ty.kind() { if alias_ty == self.alias_ty { return self.self_ty; @@ -1280,7 +1280,7 @@ where ControlFlow::Continue(()) } - fn visit_ty(&mut self, ty: I::Ty) -> Self::Result { + fn visit_ty(&mut self, ty: ty::Ty) -> Self::Result { let ty = self.ecx.replace_bound_vars(ty, &mut self.universes); let Ok(ty) = self.ecx.structurally_normalize_ty(self.param_env, ty) else { return ControlFlow::Break(Err(NoSolution)); diff --git a/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs b/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs index cd74e87b670f1..af25b3ed26e6a 100644 --- a/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs +++ b/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs @@ -21,8 +21,8 @@ use crate::solve::{AdtDestructorKind, EvalCtxt, Goal, NoSolution}; #[instrument(level = "trace", skip(ecx), ret)] pub(in crate::solve) fn instantiate_constituent_tys_for_auto_trait( ecx: &EvalCtxt<'_, D>, - ty: I::Ty, -) -> Result>, NoSolution> + ty: ty::Ty, +) -> Result>>, NoSolution> where D: SolverDelegate, I: Interner, @@ -108,8 +108,8 @@ where pub(in crate::solve) fn instantiate_constituent_tys_for_sizedness_trait( ecx: &EvalCtxt<'_, D>, sizedness: SizedTraitKind, - ty: I::Ty, -) -> Result>, NoSolution> + ty: ty::Ty, +) -> Result>>, NoSolution> where D: SolverDelegate, I: Interner, @@ -186,8 +186,8 @@ where #[instrument(level = "trace", skip(ecx), ret)] pub(in crate::solve) fn instantiate_constituent_tys_for_copy_clone_trait( ecx: &EvalCtxt<'_, D>, - ty: I::Ty, -) -> Result>, NoSolution> + ty: ty::Ty, +) -> Result>>, NoSolution> where D: SolverDelegate, I: Interner, @@ -268,9 +268,9 @@ where // Returns a binder of the tupled inputs types and output type from a builtin callable type. pub(in crate::solve) fn extract_tupled_inputs_and_output_from_callable( cx: I, - self_ty: I::Ty, + self_ty: ty::Ty, goal_kind: ty::ClosureKind, -) -> Result>, NoSolution> { +) -> Result, ty::Ty)>>, NoSolution> { match self_ty.kind() { // keep this in sync with assemble_fn_pointer_candidates until the old solver is removed. ty::FnDef(def_id, args) => { @@ -408,13 +408,13 @@ pub(in crate::solve) fn extract_tupled_inputs_and_output_from_callable { - pub tupled_inputs_ty: I::Ty, + pub tupled_inputs_ty: ty::Ty, /// Type returned by calling the closure /// i.e. `f()`. - pub output_coroutine_ty: I::Ty, + pub output_coroutine_ty: ty::Ty, /// Type returned by `await`ing the output /// i.e. `f().await`. - pub coroutine_return_ty: I::Ty, + pub coroutine_return_ty: ty::Ty, } // Returns a binder of the tupled inputs types, output type, and coroutine type @@ -424,7 +424,7 @@ pub(in crate::solve) struct AsyncCallableRelevantTypes { // know the kind already, we can short-circuit this check. pub(in crate::solve) fn extract_tupled_inputs_and_output_from_async_callable( cx: I, - self_ty: I::Ty, + self_ty: ty::Ty, goal_kind: ty::ClosureKind, env_region: I::Region, ) -> Result<(ty::Binder>, Vec), NoSolution> { @@ -608,7 +608,7 @@ fn coroutine_closure_to_certain_coroutine( def_id: I::CoroutineClosureId, args: ty::CoroutineClosureArgs, sig: ty::CoroutineClosureSignature, -) -> I::Ty { +) -> ty::Ty { sig.to_coroutine_given_kind_and_upvars( cx, args.parent_args(), @@ -632,7 +632,7 @@ fn coroutine_closure_to_ambiguous_coroutine( def_id: I::CoroutineClosureId, args: ty::CoroutineClosureArgs, sig: ty::CoroutineClosureSignature, -) -> I::Ty { +) -> ty::Ty { let upvars_projection_def_id = cx.require_lang_item(SolverLangItem::AsyncFnKindUpvars); let tupled_upvars_ty = Ty::new_projection( cx, @@ -664,8 +664,8 @@ fn coroutine_closure_to_ambiguous_coroutine( #[instrument(level = "trace", skip(cx), ret)] pub(in crate::solve) fn extract_fn_def_from_const_callable( cx: I, - self_ty: I::Ty, -) -> Result<(ty::Binder, I::DefId, I::GenericArgs), NoSolution> { + self_ty: ty::Ty, +) -> Result<(ty::Binder, ty::Ty)>, I::DefId, I::GenericArgs), NoSolution> { match self_ty.kind() { ty::FnDef(def_id, args) => { let sig = cx.fn_sig(def_id); @@ -742,7 +742,7 @@ pub(in crate::solve) fn extract_fn_def_from_const_callable( // the old solver, for as long as that exists. pub(in crate::solve) fn const_conditions_for_destruct( cx: I, - self_ty: I::Ty, + self_ty: ty::Ty, ) -> Result>, NoSolution> { let destruct_def_id = cx.require_trait_lang_item(SolverTraitLangItem::Destruct); @@ -923,7 +923,7 @@ where struct ReplaceProjectionWith<'a, 'b, I: Interner, D: SolverDelegate> { ecx: &'a mut EvalCtxt<'b, D>, param_env: I::ParamEnv, - self_ty: I::Ty, + self_ty: ty::Ty, mapping: &'a HashMap>>>, nested: Vec>, } @@ -1009,7 +1009,7 @@ where self.ecx.cx() } - fn try_fold_ty(&mut self, ty: I::Ty) -> Result { + fn try_fold_ty(&mut self, ty: ty::Ty) -> Result, Ambiguous> { if let ty::Alias(ty::Projection, alias_ty) = ty.kind() && let Some(term) = self.try_eagerly_replace_alias(alias_ty.into())? { diff --git a/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs b/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs index 4b1e4b2de571d..9a0a82acbc931 100644 --- a/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs +++ b/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs @@ -13,7 +13,7 @@ use super::assembly::{Candidate, structural_traits}; use crate::delegate::SolverDelegate; use crate::solve::{ BuiltinImplSource, CandidateSource, Certainty, EvalCtxt, Goal, GoalSource, NoSolution, - QueryResult, assembly, + QueryResult, Ty, assembly, }; impl assembly::GoalKind for ty::HostEffectPredicate @@ -21,7 +21,7 @@ where D: SolverDelegate, I: Interner, { - fn self_ty(self) -> I::Ty { + fn self_ty(self) -> Ty { self.self_ty() } @@ -29,7 +29,7 @@ where self.trait_ref } - fn with_replaced_self_ty(self, cx: I, self_ty: I::Ty) -> Self { + fn with_replaced_self_ty(self, cx: I, self_ty: Ty) -> Self { self.with_replaced_self_ty(cx, self_ty) } diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs index 6841fe1c5124e..d6ed220909732 100644 --- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs +++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs @@ -10,7 +10,7 @@ use rustc_type_ir::relate::solver_relating::RelateExt; use rustc_type_ir::search_graph::{CandidateHeadUsages, PathKind}; use rustc_type_ir::solve::OpaqueTypesJank; use rustc_type_ir::{ - self as ty, CanonicalVarValues, InferCtxtLike, Interner, TypeFoldable, TypeFolder, + self as ty, CanonicalVarValues, InferCtxtLike, Interner, Ty, TypeFoldable, TypeFolder, TypeSuperFoldable, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor, TypingMode, }; @@ -781,7 +781,7 @@ where region } - pub(super) fn next_ty_infer(&mut self) -> I::Ty { + pub(super) fn next_ty_infer(&mut self) -> Ty { let ty = self.delegate.next_ty_infer(); self.inspect.add_var_value(ty); ty @@ -829,7 +829,7 @@ where term: I::Term, universe_of_term: ty::UniverseIndex, delegate: &'a D, - cache: HashSet, + cache: HashSet>, } impl, I: Interner> ContainsTermOrNotNameable<'_, D, I> { @@ -846,7 +846,7 @@ where for ContainsTermOrNotNameable<'_, D, I> { type Result = ControlFlow<()>; - fn visit_ty(&mut self, t: I::Ty) -> Self::Result { + fn visit_ty(&mut self, t: Ty) -> Self::Result { if self.cache.contains(&t) { return ControlFlow::Continue(()); } @@ -1072,7 +1072,7 @@ where self.delegate.resolve_vars_if_possible(value) } - pub(super) fn shallow_resolve(&self, ty: I::Ty) -> I::Ty { + pub(super) fn shallow_resolve(&self, ty: Ty) -> Ty { self.delegate.shallow_resolve(ty) } @@ -1092,7 +1092,7 @@ where args } - pub(super) fn register_ty_outlives(&self, ty: I::Ty, lt: I::Region) { + pub(super) fn register_ty_outlives(&self, ty: Ty, lt: I::Region) { self.delegate.register_ty_outlives(ty, lt, self.origin_span); } @@ -1134,8 +1134,8 @@ where pub(super) fn register_hidden_type_in_storage( &mut self, opaque_type_key: ty::OpaqueTypeKey, - hidden_ty: I::Ty, - ) -> Option { + hidden_ty: Ty, + ) -> Option> { self.delegate.register_hidden_type_in_storage(opaque_type_key, hidden_ty, self.origin_span) } @@ -1144,7 +1144,7 @@ where opaque_def_id: I::DefId, opaque_args: I::GenericArgs, param_env: I::ParamEnv, - hidden_ty: I::Ty, + hidden_ty: Ty, ) { let mut goals = Vec::new(); self.delegate.add_item_bounds_for_hidden_type( @@ -1170,8 +1170,8 @@ where pub(super) fn is_transmutable( &mut self, - src: I::Ty, - dst: I::Ty, + src: Ty, + dst: Ty, assume: I::Const, ) -> Result { self.delegate.is_transmutable(dst, src, assume) @@ -1195,7 +1195,7 @@ where pub(crate) fn opaques_with_sub_unified_hidden_type( &self, - self_ty: I::Ty, + self_ty: Ty, ) -> Vec> { if let ty::Infer(ty::TyVar(vid)) = self_ty.kind() { self.delegate.opaques_with_sub_unified_hidden_type(vid) @@ -1389,7 +1389,7 @@ where ecx: &'me mut EvalCtxt<'a, D>, param_env: I::ParamEnv, normalization_goal_source: GoalSource, - cache: HashMap, + cache: HashMap, Ty>, } impl<'me, 'a, D, I> ReplaceAliasWithInfer<'me, 'a, D, I> @@ -1421,7 +1421,7 @@ where self.ecx.cx() } - fn fold_ty(&mut self, ty: I::Ty) -> I::Ty { + fn fold_ty(&mut self, ty: Ty) -> Ty { match ty.kind() { ty::Alias(..) if !ty.has_escaping_bound_vars() => { let infer_ty = self.ecx.next_ty_infer(); diff --git a/compiler/rustc_next_trait_solver/src/solve/mod.rs b/compiler/rustc_next_trait_solver/src/solve/mod.rs index 58bd7cf663d98..71b28cf1ad277 100644 --- a/compiler/rustc_next_trait_solver/src/solve/mod.rs +++ b/compiler/rustc_next_trait_solver/src/solve/mod.rs @@ -24,7 +24,7 @@ mod trait_goals; use derive_where::derive_where; use rustc_type_ir::inherent::*; pub use rustc_type_ir::solve::*; -use rustc_type_ir::{self as ty, Interner, TyVid, TypingMode}; +use rustc_type_ir::{self as ty, Interner, Ty, TyVid, TypingMode}; use tracing::instrument; pub use self::eval_ctxt::{ @@ -88,7 +88,7 @@ where #[instrument(level = "trace", skip(self))] fn compute_type_outlives_goal( &mut self, - goal: Goal>, + goal: Goal>>, ) -> QueryResult { let ty::OutlivesPredicate(ty, lt) = goal.predicate; self.register_ty_outlives(ty, lt); @@ -205,7 +205,7 @@ where #[instrument(level = "trace", skip(self), ret)] fn compute_const_arg_has_type_goal( &mut self, - goal: Goal, + goal: Goal)>, ) -> QueryResult { let (ct, ty) = goal.predicate; let ct = self.structurally_normalize_const(goal.param_env, ct)?; @@ -315,8 +315,8 @@ where fn structurally_normalize_ty( &mut self, param_env: I::ParamEnv, - ty: I::Ty, - ) -> Result { + ty: Ty, + ) -> Result, NoSolution> { self.structurally_normalize_term(param_env, ty.into()).map(|term| term.expect_ty()) } diff --git a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs index 13f2ad8f82eba..13ed945857db2 100644 --- a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs +++ b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs @@ -125,7 +125,7 @@ where D: SolverDelegate, I: Interner, { - fn self_ty(self) -> I::Ty { + fn self_ty(self) -> ty::Ty { self.self_ty() } @@ -133,7 +133,7 @@ where self.alias.trait_ref(cx) } - fn with_replaced_self_ty(self, cx: I, self_ty: I::Ty) -> Self { + fn with_replaced_self_ty(self, cx: I, self_ty: ty::Ty) -> Self { self.with_replaced_self_ty(cx, self_ty) } diff --git a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs index 6589a12c4cc2d..82051b2fea4ef 100644 --- a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs +++ b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs @@ -29,7 +29,7 @@ where D: SolverDelegate, I: Interner, { - fn self_ty(self) -> I::Ty { + fn self_ty(self) -> ty::Ty { self.self_ty() } @@ -37,7 +37,7 @@ where self.trait_ref } - fn with_replaced_self_ty(self, cx: I, self_ty: I::Ty) -> Self { + fn with_replaced_self_ty(self, cx: I, self_ty: ty::Ty) -> Self { self.with_replaced_self_ty(cx, self_ty) } @@ -929,7 +929,7 @@ where /// ``` fn consider_builtin_dyn_upcast_candidates( &mut self, - goal: Goal, + goal: Goal, ty::Ty)>, a_data: I::BoundExistentialPredicates, a_region: I::Region, b_data: I::BoundExistentialPredicates, @@ -977,7 +977,7 @@ where fn consider_builtin_unsize_to_dyn_candidate( &mut self, - goal: Goal, + goal: Goal, ty::Ty)>, b_data: I::BoundExistentialPredicates, b_region: I::Region, ) -> Result, NoSolution> { @@ -1018,7 +1018,7 @@ where fn consider_builtin_upcast_to_principal( &mut self, - goal: Goal, + goal: Goal, ty::Ty)>, source: CandidateSource, a_data: I::BoundExistentialPredicates, a_region: I::Region, @@ -1132,9 +1132,9 @@ where /// `#[rustc_deny_explicit_impl]` in this case. fn consider_builtin_array_unsize( &mut self, - goal: Goal, - a_elem_ty: I::Ty, - b_elem_ty: I::Ty, + goal: Goal, ty::Ty)>, + a_elem_ty: ty::Ty, + b_elem_ty: ty::Ty, ) -> Result, NoSolution> { self.eq(goal.param_env, a_elem_ty, b_elem_ty)?; self.probe_builtin_trait_candidate(BuiltinImplSource::Misc) @@ -1156,7 +1156,7 @@ where /// ``` fn consider_builtin_struct_unsize( &mut self, - goal: Goal, + goal: Goal, ty::Ty)>, def: I::AdtDef, a_args: I::GenericArgs, b_args: I::GenericArgs, @@ -1319,8 +1319,8 @@ where goal: Goal>, constituent_tys: impl Fn( &EvalCtxt<'_, D>, - I::Ty, - ) -> Result>, NoSolution>, + ty::Ty, + ) -> Result>>, NoSolution>, ) -> Result, NoSolution> { self.probe_trait_candidate(source).enter(|ecx| { let goals = @@ -1542,7 +1542,10 @@ where self.merge_trait_candidates(candidate_preference_mode, candidates, failed_candidate_info) } - fn try_stall_coroutine(&mut self, self_ty: I::Ty) -> Option, NoSolution>> { + fn try_stall_coroutine( + &mut self, + self_ty: ty::Ty, + ) -> Option, NoSolution>> { if let ty::Coroutine(def_id, _) = self_ty.kind() { match self.typing_mode() { TypingMode::Analysis { diff --git a/compiler/rustc_type_ir/src/binder.rs b/compiler/rustc_type_ir/src/binder.rs index 0b0f0fd2f4249..6528aa7526b21 100644 --- a/compiler/rustc_type_ir/src/binder.rs +++ b/compiler/rustc_type_ir/src/binder.rs @@ -16,7 +16,7 @@ use crate::fold::{FallibleTypeFolder, TypeFoldable, TypeFolder, TypeSuperFoldabl use crate::inherent::*; use crate::lift::Lift; use crate::visit::{Flags, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor}; -use crate::{self as ty, DebruijnIndex, Interner, UniverseIndex}; +use crate::{self as ty, DebruijnIndex, Interner, Ty, UniverseIndex}; /// `Binder` is a binder for higher-ranked lifetimes or types. It is part of the /// compiler's representation for things like `for<'a> Fn(&'a isize)` @@ -274,7 +274,7 @@ pub struct ValidateBoundVars { // We only cache types because any complex const will have to step through // a type at some point anyways. We may encounter the same variable at // different levels of binding, so this can't just be `Ty`. - visited: SsoHashSet<(ty::DebruijnIndex, I::Ty)>, + visited: SsoHashSet<(ty::DebruijnIndex, Ty)>, } impl ValidateBoundVars { @@ -297,7 +297,7 @@ impl TypeVisitor for ValidateBoundVars { result } - fn visit_ty(&mut self, t: I::Ty) -> Self::Result { + fn visit_ty(&mut self, t: Ty) -> Self::Result { if t.outer_exclusive_binder() < self.binder_index || !self.visited.insert((self.binder_index, t)) { @@ -724,7 +724,7 @@ impl<'a, I: Interner> TypeFolder for ArgFolder<'a, I> { } } - fn fold_ty(&mut self, t: I::Ty) -> I::Ty { + fn fold_ty(&mut self, t: Ty) -> Ty { if !t.has_param() { return t; } @@ -753,7 +753,7 @@ impl<'a, I: Interner> TypeFolder for ArgFolder<'a, I> { } impl<'a, I: Interner> ArgFolder<'a, I> { - fn ty_for_param(&self, p: I::ParamTy, source_ty: I::Ty) -> I::Ty { + fn ty_for_param(&self, p: I::ParamTy, source_ty: Ty) -> Ty { // Look up the type in the args. It really should be in there. let opt_ty = self.args.get(p.index() as usize).map(|arg| arg.kind()); let ty = match opt_ty { @@ -767,7 +767,7 @@ impl<'a, I: Interner> ArgFolder<'a, I> { #[cold] #[inline(never)] - fn type_param_expected(&self, p: I::ParamTy, ty: I::Ty, kind: ty::GenericArgKind) -> ! { + fn type_param_expected(&self, p: I::ParamTy, ty: Ty, kind: ty::GenericArgKind) -> ! { panic!( "expected type for `{:?}` ({:?}/{}) but found {:?} when instantiating, args={:?}", p, @@ -780,7 +780,7 @@ impl<'a, I: Interner> ArgFolder<'a, I> { #[cold] #[inline(never)] - fn type_param_out_of_range(&self, p: I::ParamTy, ty: I::Ty) -> ! { + fn type_param_out_of_range(&self, p: I::ParamTy, ty: Ty) -> ! { panic!( "type parameter `{:?}` ({:?}/{}) out of range when instantiating, args={:?}", p, @@ -1277,7 +1277,7 @@ impl PlaceholderConst { Self { universe: ui, bound, _tcx: PhantomData } } - pub fn find_const_ty_from_env(self, env: I::ParamEnv) -> I::Ty { + pub fn find_const_ty_from_env(self, env: I::ParamEnv) -> Ty { let mut candidates = env.caller_bounds().iter().filter_map(|clause| { // `ConstArgHasType` are never desugared to be higher ranked. match clause.kind().skip_binder() { diff --git a/compiler/rustc_type_ir/src/error.rs b/compiler/rustc_type_ir/src/error.rs index eba4c7c6644ac..ef542af7f1f9a 100644 --- a/compiler/rustc_type_ir/src/error.rs +++ b/compiler/rustc_type_ir/src/error.rs @@ -2,7 +2,7 @@ use derive_where::derive_where; use rustc_type_ir_macros::{GenericTypeVisitable, TypeFoldable_Generic, TypeVisitable_Generic}; use crate::solve::NoSolution; -use crate::{self as ty, Interner}; +use crate::{self as ty, Interner, Ty}; #[derive(Clone, Copy, Debug, PartialEq, Eq)] #[derive(TypeFoldable_Generic, TypeVisitable_Generic, GenericTypeVisitable)] @@ -36,15 +36,15 @@ pub enum TypeError { RegionsInsufficientlyPolymorphic(ty::BoundRegion, I::Region), RegionsPlaceholderMismatch, - Sorts(ExpectedFound), - ArgumentSorts(ExpectedFound, usize), + Sorts(ExpectedFound>), + ArgumentSorts(ExpectedFound>, usize), Traits(ExpectedFound), VariadicMismatch(ExpectedFound), /// Instantiating a type variable with the given type would have /// created a cycle (because it appears somewhere within that /// type). - CyclicTy(I::Ty), + CyclicTy(Ty), CyclicConst(I::Const), ProjectionMismatched(ExpectedFound), ExistentialMismatch(ExpectedFound), diff --git a/compiler/rustc_type_ir/src/fast_reject.rs b/compiler/rustc_type_ir/src/fast_reject.rs index ed6416a7f55f2..72b58776565b5 100644 --- a/compiler/rustc_type_ir/src/fast_reject.rs +++ b/compiler/rustc_type_ir/src/fast_reject.rs @@ -113,7 +113,7 @@ pub enum TreatParams { /// ¹ meaning that if the outermost layers are different, then the whole types are also different. pub fn simplify_type( cx: I, - ty: I::Ty, + ty: ty::Ty, treat_params: TreatParams, ) -> Option> { match ty.kind() { @@ -236,11 +236,16 @@ impl bool { + pub fn types_may_unify(self, lhs: ty::Ty, rhs: ty::Ty) -> bool { self.types_may_unify_inner(lhs, rhs, Self::STARTING_DEPTH) } - pub fn types_may_unify_with_depth(self, lhs: I::Ty, rhs: I::Ty, depth_limit: usize) -> bool { + pub fn types_may_unify_with_depth( + self, + lhs: ty::Ty, + rhs: ty::Ty, + depth_limit: usize, + ) -> bool { self.types_may_unify_inner(lhs, rhs, depth_limit) } @@ -268,7 +273,7 @@ impl bool { + fn types_may_unify_inner(self, lhs: ty::Ty, rhs: ty::Ty, depth: usize) -> bool { if lhs == rhs { return true; } @@ -527,7 +532,7 @@ impl bool { + fn var_and_ty_may_unify(self, var: ty::InferTy, ty: ty::Ty) -> bool { if !ty.is_known_rigid() { return true; } diff --git a/compiler/rustc_type_ir/src/flags.rs b/compiler/rustc_type_ir/src/flags.rs index 7e905da0785f8..6962a7ab1d727 100644 --- a/compiler/rustc_type_ir/src/flags.rs +++ b/compiler/rustc_type_ir/src/flags.rs @@ -1,6 +1,6 @@ use crate::inherent::*; use crate::visit::Flags; -use crate::{self as ty, Interner}; +use crate::{self as ty, Interner, Ty}; bitflags::bitflags! { /// Flags that we track on types. These flags are propagated upwards @@ -430,7 +430,7 @@ impl FlagComputation { } } - fn add_ty(&mut self, ty: I::Ty) { + fn add_ty(&mut self, ty: Ty) { self.add_flags(ty.flags()); self.add_exclusive_binder(ty.outer_exclusive_binder()); } diff --git a/compiler/rustc_type_ir/src/fold.rs b/compiler/rustc_type_ir/src/fold.rs index d1a50599e8b9c..ef162b21b660e 100644 --- a/compiler/rustc_type_ir/src/fold.rs +++ b/compiler/rustc_type_ir/src/fold.rs @@ -135,7 +135,7 @@ pub trait TypeFolder: Sized { t.super_fold_with(self) } - fn fold_ty(&mut self, t: I::Ty) -> I::Ty { + fn fold_ty(&mut self, t: ty::Ty) -> ty::Ty { t.super_fold_with(self) } @@ -177,7 +177,7 @@ pub trait FallibleTypeFolder: Sized { t.try_super_fold_with(self) } - fn try_fold_ty(&mut self, t: I::Ty) -> Result { + fn try_fold_ty(&mut self, t: ty::Ty) -> Result, Self::Error> { t.try_super_fold_with(self) } @@ -408,7 +408,7 @@ impl TypeFolder for Shifter { } } - fn fold_ty(&mut self, ty: I::Ty) -> I::Ty { + fn fold_ty(&mut self, ty: ty::Ty) -> ty::Ty { match ty.kind() { ty::Bound(BoundVarIndexKind::Bound(debruijn), bound_ty) if debruijn >= self.current_index => @@ -538,7 +538,7 @@ where } } - fn fold_ty(&mut self, t: I::Ty) -> I::Ty { + fn fold_ty(&mut self, t: ty::Ty) -> ty::Ty { if t.has_type_flags( TypeFlags::HAS_FREE_REGIONS | TypeFlags::HAS_RE_BOUND | TypeFlags::HAS_RE_ERASED, ) { diff --git a/compiler/rustc_type_ir/src/generic_arg.rs b/compiler/rustc_type_ir/src/generic_arg.rs index 5d612740fdd84..22a4ebd03b69c 100644 --- a/compiler/rustc_type_ir/src/generic_arg.rs +++ b/compiler/rustc_type_ir/src/generic_arg.rs @@ -3,7 +3,7 @@ use derive_where::derive_where; use rustc_macros::{Decodable_NoContext, Encodable_NoContext, HashStable_NoContext}; use rustc_type_ir_macros::GenericTypeVisitable; -use crate::Interner; +use crate::{Interner, Ty}; #[derive_where(Clone, Copy, PartialEq, Debug; I: Interner)] #[derive(GenericTypeVisitable)] @@ -13,7 +13,7 @@ use crate::Interner; )] pub enum GenericArgKind { Lifetime(I::Region), - Type(I::Ty), + Type(Ty), Const(I::Const), } @@ -26,7 +26,7 @@ impl Eq for GenericArgKind {} derive(Decodable_NoContext, Encodable_NoContext, HashStable_NoContext) )] pub enum TermKind { - Ty(I::Ty), + Ty(Ty), Const(I::Const), } diff --git a/compiler/rustc_type_ir/src/infer_ctxt.rs b/compiler/rustc_type_ir/src/infer_ctxt.rs index feafcee7bad9e..843d1eb37b7d9 100644 --- a/compiler/rustc_type_ir/src/infer_ctxt.rs +++ b/compiler/rustc_type_ir/src/infer_ctxt.rs @@ -6,7 +6,7 @@ use crate::fold::TypeFoldable; use crate::inherent::*; use crate::relate::RelateResult; use crate::relate::combine::PredicateEmittingRelation; -use crate::{self as ty, Interner, TyVid}; +use crate::{self as ty, Interner, Ty, TyVid}; /// The current typing mode of an inference context. We unfortunately have some /// slightly different typing rules depending on the current context. See the @@ -161,12 +161,9 @@ pub trait InferCtxtLike: Sized { fn sub_unification_table_root_var(&self, var: ty::TyVid) -> ty::TyVid; fn root_const_var(&self, var: ty::ConstVid) -> ty::ConstVid; - fn opportunistic_resolve_ty_var(&self, vid: ty::TyVid) -> ::Ty; - fn opportunistic_resolve_int_var(&self, vid: ty::IntVid) -> ::Ty; - fn opportunistic_resolve_float_var( - &self, - vid: ty::FloatVid, - ) -> ::Ty; + fn opportunistic_resolve_ty_var(&self, vid: ty::TyVid) -> Ty; + fn opportunistic_resolve_int_var(&self, vid: ty::IntVid) -> Ty; + fn opportunistic_resolve_float_var(&self, vid: ty::FloatVid) -> Ty; fn opportunistic_resolve_ct_var( &self, vid: ty::ConstVid, @@ -179,7 +176,7 @@ pub trait InferCtxtLike: Sized { fn is_changed_arg(&self, arg: ::GenericArg) -> bool; fn next_region_infer(&self) -> ::Region; - fn next_ty_infer(&self) -> ::Ty; + fn next_ty_infer(&self) -> Ty; fn next_const_infer(&self) -> ::Const; fn fresh_args_for_item( &self, @@ -209,7 +206,7 @@ pub trait InferCtxtLike: Sized { target_is_expected: bool, target_vid: ty::TyVid, instantiation_variance: ty::Variance, - source_ty: ::Ty, + source_ty: Ty, ) -> RelateResult; fn instantiate_int_var_raw(&self, vid: ty::IntVid, value: ty::IntVarValue); fn instantiate_float_var_raw(&self, vid: ty::FloatVid, value: ty::FloatVarValue); @@ -223,10 +220,7 @@ pub trait InferCtxtLike: Sized { fn set_tainted_by_errors(&self, e: ::ErrorGuaranteed); - fn shallow_resolve( - &self, - ty: ::Ty, - ) -> ::Ty; + fn shallow_resolve(&self, ty: Ty) -> Ty; fn shallow_resolve_const( &self, ty: ::Const, @@ -254,7 +248,7 @@ pub trait InferCtxtLike: Sized { fn register_ty_outlives( &self, - ty: ::Ty, + ty: Ty, r: ::Region, span: ::Span, ); @@ -263,26 +257,26 @@ pub trait InferCtxtLike: Sized { fn opaque_types_storage_num_entries(&self) -> Self::OpaqueTypeStorageEntries; fn clone_opaque_types_lookup_table( &self, - ) -> Vec<(ty::OpaqueTypeKey, ::Ty)>; + ) -> Vec<(ty::OpaqueTypeKey, Ty)>; fn clone_duplicate_opaque_types( &self, - ) -> Vec<(ty::OpaqueTypeKey, ::Ty)>; + ) -> Vec<(ty::OpaqueTypeKey, Ty)>; fn clone_opaque_types_added_since( &self, prev_entries: Self::OpaqueTypeStorageEntries, - ) -> Vec<(ty::OpaqueTypeKey, ::Ty)>; + ) -> Vec<(ty::OpaqueTypeKey, Ty)>; fn opaques_with_sub_unified_hidden_type(&self, ty: TyVid) -> Vec>; fn register_hidden_type_in_storage( &self, opaque_type_key: ty::OpaqueTypeKey, - hidden_ty: ::Ty, + hidden_ty: Ty, span: ::Span, - ) -> Option<::Ty>; + ) -> Option>; fn add_duplicate_opaque_type( &self, opaque_type_key: ty::OpaqueTypeKey, - hidden_ty: ::Ty, + hidden_ty: Ty, span: ::Span, ); diff --git a/compiler/rustc_type_ir/src/inherent.rs b/compiler/rustc_type_ir/src/inherent.rs index 116fd100bf0a9..45590561d9d08 100644 --- a/compiler/rustc_type_ir/src/inherent.rs +++ b/compiler/rustc_type_ir/src/inherent.rs @@ -55,7 +55,7 @@ pub trait Ty>: fn new_alias(interner: I, kind: ty::AliasTyKind, alias_ty: ty::AliasTy) -> Self; fn new_projection_from_args(interner: I, def_id: I::DefId, args: I::GenericArgs) -> Self { - Ty::new_alias( + Self::new_alias( interner, ty::AliasTyKind::Projection, ty::AliasTy::new_from_args(interner, def_id, args), @@ -67,7 +67,7 @@ pub trait Ty>: def_id: I::DefId, args: impl IntoIterator>, ) -> Self { - Ty::new_alias( + Self::new_alias( interner, ty::AliasTyKind::Projection, ty::AliasTy::new(interner, def_id, args), @@ -108,7 +108,7 @@ pub trait Ty>: fn new_slice(interner: I, ty: Self) -> Self; - fn new_tup(interner: I, tys: &[I::Ty]) -> Self; + fn new_tup(interner: I, tys: &[ty::Ty]) -> Self; fn new_tup_from_iter(interner: I, iter: It) -> T::Output where @@ -121,7 +121,7 @@ pub trait Ty>: fn new_pat(interner: I, ty: Self, pat: I::Pat) -> Self; - fn new_unsafe_binder(interner: I, ty: ty::Binder) -> Self; + fn new_unsafe_binder(interner: I, ty: ty::Binder>) -> Self; fn tuple_fields(self) -> I::Tys; @@ -158,7 +158,7 @@ pub trait Ty>: self.kind().fn_sig(interner) } - fn discriminant_ty(self, interner: I) -> I::Ty; + fn discriminant_ty(self, interner: I) -> ty::Ty; fn is_known_rigid(self) -> bool { self.kind().is_known_rigid() @@ -198,11 +198,11 @@ pub trait Ty>: } pub trait Tys>: - Copy + Debug + Hash + Eq + SliceLike + TypeFoldable + Default + Copy + Debug + Hash + Eq + SliceLike> + TypeFoldable + Default { fn inputs(self) -> I::FnInputTys; - fn output(self) -> I::Ty; + fn output(self) -> ty::Ty; } pub trait Abi>: Copy + Debug + Hash + Eq { @@ -290,7 +290,7 @@ pub trait Const>: } pub trait ValueConst>: Copy + Debug + Hash + Eq { - fn ty(self) -> I::Ty; + fn ty(self) -> ty::Ty; fn valtree(self) -> I::ValTree; } @@ -310,7 +310,7 @@ pub trait GenericArg>: + IntoKind> + TypeVisitable + Relate - + From + + From> + From + From + From @@ -323,11 +323,11 @@ pub trait GenericArg>: } } - fn as_type(&self) -> Option { + fn as_type(&self) -> Option> { if let ty::GenericArgKind::Type(ty) = self.kind() { Some(ty) } else { None } } - fn expect_ty(&self) -> I::Ty { + fn expect_ty(&self) -> ty::Ty { self.as_type().expect("expected a type") } @@ -359,11 +359,11 @@ pub trait GenericArg>: pub trait Term>: Copy + Debug + Hash + Eq + IntoKind> + TypeFoldable + Relate { - fn as_type(&self) -> Option { + fn as_type(&self) -> Option> { if let ty::TermKind::Ty(ty) = self.kind() { Some(ty) } else { None } } - fn expect_ty(&self) -> I::Ty { + fn expect_ty(&self) -> ty::Ty { self.as_type().expect("expected a type, but found a const") } @@ -413,7 +413,7 @@ pub trait GenericArgs>: target: I::GenericArgs, ) -> I::GenericArgs; - fn type_at(self, i: usize) -> I::Ty; + fn type_at(self, i: usize) -> ty::Ty; fn region_at(self, i: usize) -> I::Region; @@ -459,7 +459,7 @@ pub trait Predicate>: + UpcastFrom> + UpcastFrom>> + UpcastFrom> - + UpcastFrom> + + UpcastFrom>> + UpcastFrom> + IntoKind>> + Elaboratable @@ -578,7 +578,7 @@ pub trait AdtDef: Copy + Debug + Hash + Eq { /// Returns the type of the struct tail. /// /// Expects the `AdtDef` to be a struct. If it is not, then this will panic. - fn struct_tail_ty(self, interner: I) -> Option>; + fn struct_tail_ty(self, interner: I) -> Option>>; fn is_phantom_data(self) -> bool; @@ -591,13 +591,13 @@ pub trait AdtDef: Copy + Debug + Hash + Eq { ) -> Option>; // FIXME: perhaps use `all_fields` and expose `FieldDef`. - fn all_field_tys(self, interner: I) -> ty::EarlyBinder>; + fn all_field_tys(self, interner: I) -> ty::EarlyBinder>>; fn sizedness_constraint( self, interner: I, sizedness: SizedTraitKind, - ) -> Option>; + ) -> Option>>; fn is_fundamental(self) -> bool; diff --git a/compiler/rustc_type_ir/src/lib.rs b/compiler/rustc_type_ir/src/lib.rs index a0b444024ca79..6c838cf8a48ac 100644 --- a/compiler/rustc_type_ir/src/lib.rs +++ b/compiler/rustc_type_ir/src/lib.rs @@ -31,6 +31,7 @@ pub mod outlives; pub mod relate; pub mod search_graph; pub mod solve; +pub mod sty; pub mod walk; // These modules are not `pub` since they are glob-imported. @@ -78,6 +79,7 @@ pub use predicate_kind::*; pub use region_kind::*; pub use rustc_ast_ir::{FloatTy, IntTy, Movability, Mutability, Pinnedness, UintTy}; use rustc_type_ir_macros::GenericTypeVisitable; +pub use sty::*; pub use ty_info::*; pub use ty_kind::*; pub use upcast::*; @@ -443,8 +445,8 @@ impl fmt::Display for ClosureKind { } pub struct FieldInfo { - pub base: I::Ty, - pub ty: I::Ty, + pub base: Ty, + pub ty: Ty, pub variant: Option, pub variant_idx: VariantIdx, pub name: I::Symbol, diff --git a/compiler/rustc_type_ir/src/outlives.rs b/compiler/rustc_type_ir/src/outlives.rs index 300e5c0b46956..cc79d6589e6fb 100644 --- a/compiler/rustc_type_ir/src/outlives.rs +++ b/compiler/rustc_type_ir/src/outlives.rs @@ -8,7 +8,7 @@ use smallvec::{SmallVec, smallvec}; use crate::data_structures::SsoHashSet; use crate::inherent::*; use crate::visit::{TypeSuperVisitable, TypeVisitable, TypeVisitableExt as _, TypeVisitor}; -use crate::{self as ty, Interner}; +use crate::{self as ty, Interner, Ty}; #[derive_where(Debug; I: Interner)] pub enum Component { @@ -55,7 +55,7 @@ pub enum Component { /// `ty0: 'a` to hold. Note that `ty0` must be a **fully resolved type**. pub fn push_outlives_components( cx: I, - ty: I::Ty, + ty: Ty, out: &mut SmallVec<[Component; 4]>, ) { ty.visit_with(&mut OutlivesCollector { cx, out, visited: Default::default() }); @@ -64,14 +64,14 @@ pub fn push_outlives_components( struct OutlivesCollector<'a, I: Interner> { cx: I, out: &'a mut SmallVec<[Component; 4]>, - visited: SsoHashSet, + visited: SsoHashSet>, } impl TypeVisitor for OutlivesCollector<'_, I> { #[cfg(not(feature = "nightly"))] type Result = (); - fn visit_ty(&mut self, ty: I::Ty) -> Self::Result { + fn visit_ty(&mut self, ty: Ty) -> Self::Result { if !self.visited.insert(ty) { return; } diff --git a/compiler/rustc_type_ir/src/predicate.rs b/compiler/rustc_type_ir/src/predicate.rs index 113192cc02eb8..f4975f3ad4486 100644 --- a/compiler/rustc_type_ir/src/predicate.rs +++ b/compiler/rustc_type_ir/src/predicate.rs @@ -101,7 +101,7 @@ impl TraitRef { ) } - pub fn with_replaced_self_ty(self, interner: I, self_ty: I::Ty) -> Self { + pub fn with_replaced_self_ty(self, interner: I, self_ty: ty::Ty) -> Self { TraitRef::new( interner, self.def_id, @@ -110,13 +110,13 @@ impl TraitRef { } #[inline] - pub fn self_ty(&self) -> I::Ty { + pub fn self_ty(&self) -> ty::Ty { self.args.type_at(0) } } impl ty::Binder> { - pub fn self_ty(&self) -> ty::Binder { + pub fn self_ty(&self) -> ty::Binder> { self.map_bound_ref(|tr| tr.self_ty()) } @@ -152,7 +152,7 @@ pub struct TraitPredicate { impl Eq for TraitPredicate {} impl TraitPredicate { - pub fn with_replaced_self_ty(self, interner: I, self_ty: I::Ty) -> Self { + pub fn with_replaced_self_ty(self, interner: I, self_ty: ty::Ty) -> Self { Self { trait_ref: self.trait_ref.with_replaced_self_ty(interner, self_ty), polarity: self.polarity, @@ -163,7 +163,7 @@ impl TraitPredicate { self.trait_ref.def_id } - pub fn self_ty(self) -> I::Ty { + pub fn self_ty(self) -> ty::Ty { self.trait_ref.self_ty() } } @@ -174,7 +174,7 @@ impl ty::Binder> { self.skip_binder().def_id() } - pub fn self_ty(self) -> ty::Binder { + pub fn self_ty(self) -> ty::Binder> { self.map_bound(|trait_ref| trait_ref.self_ty()) } @@ -307,7 +307,7 @@ impl ty::Binder> { /// Given an existential predicate like `?Self: PartialEq` (e.g., derived from `dyn PartialEq`), /// and a concrete type `self_ty`, returns a full predicate where the existentially quantified variable `?Self` /// has been replaced with `self_ty` (e.g., `self_ty: PartialEq`, in our example). - pub fn with_self_ty(&self, cx: I, self_ty: I::Ty) -> I::Clause { + pub fn with_self_ty(&self, cx: I, self_ty: ty::Ty) -> I::Clause { match self.skip_binder() { ExistentialPredicate::Trait(tr) => self.rebind(tr).with_self_ty(cx, self_ty).upcast(cx), ExistentialPredicate::Projection(p) => { @@ -384,7 +384,7 @@ impl ExistentialTraitRef { /// we convert the principal trait-ref into a normal trait-ref, /// you must give *some* self type. A common choice is `mk_err()` /// or some placeholder type. - pub fn with_self_ty(self, interner: I, self_ty: I::Ty) -> TraitRef { + pub fn with_self_ty(self, interner: I, self_ty: ty::Ty) -> TraitRef { // otherwise the escaping vars would be captured by the binder // debug_assert!(!self_ty.has_escaping_bound_vars()); @@ -401,7 +401,7 @@ impl ty::Binder> { /// we convert the principal trait-ref into a normal trait-ref, /// you must give *some* self type. A common choice is `mk_err()` /// or some placeholder type. - pub fn with_self_ty(&self, cx: I, self_ty: I::Ty) -> ty::Binder> { + pub fn with_self_ty(&self, cx: I, self_ty: ty::Ty) -> ty::Binder> { self.map_bound(|trait_ref| trait_ref.with_self_ty(cx, self_ty)) } } @@ -459,7 +459,7 @@ impl ExistentialProjection { ExistentialTraitRef::new_from_args(interner, def_id.try_into().unwrap(), args) } - pub fn with_self_ty(&self, interner: I, self_ty: I::Ty) -> ProjectionPredicate { + pub fn with_self_ty(&self, interner: I, self_ty: ty::Ty) -> ProjectionPredicate { // otherwise the escaping regions would be captured by the binders debug_assert!(!self_ty.has_escaping_bound_vars()); @@ -487,7 +487,7 @@ impl ExistentialProjection { } impl ty::Binder> { - pub fn with_self_ty(&self, cx: I, self_ty: I::Ty) -> ty::Binder> { + pub fn with_self_ty(&self, cx: I, self_ty: ty::Ty) -> ty::Binder> { self.map_bound(|p| p.with_self_ty(cx, self_ty)) } @@ -683,11 +683,11 @@ impl AliasTerm { /// The following methods work only with (trait) associated term projections. impl AliasTerm { - pub fn self_ty(self) -> I::Ty { + pub fn self_ty(self) -> ty::Ty { self.args.type_at(0) } - pub fn with_replaced_self_ty(self, interner: I, self_ty: I::Ty) -> Self { + pub fn with_replaced_self_ty(self, interner: I, self_ty: ty::Ty) -> Self { AliasTerm::new( interner, self.def_id, @@ -796,11 +796,11 @@ pub struct ProjectionPredicate { impl Eq for ProjectionPredicate {} impl ProjectionPredicate { - pub fn self_ty(self) -> I::Ty { + pub fn self_ty(self) -> ty::Ty { self.projection_term.self_ty() } - pub fn with_replaced_self_ty(self, interner: I, self_ty: I::Ty) -> ProjectionPredicate { + pub fn with_replaced_self_ty(self, interner: I, self_ty: ty::Ty) -> ProjectionPredicate { Self { projection_term: self.projection_term.with_replaced_self_ty(interner, self_ty), ..self @@ -859,11 +859,11 @@ pub struct NormalizesTo { impl Eq for NormalizesTo {} impl NormalizesTo { - pub fn self_ty(self) -> I::Ty { + pub fn self_ty(self) -> ty::Ty { self.alias.self_ty() } - pub fn with_replaced_self_ty(self, interner: I, self_ty: I::Ty) -> NormalizesTo { + pub fn with_replaced_self_ty(self, interner: I, self_ty: ty::Ty) -> NormalizesTo { Self { alias: self.alias.with_replaced_self_ty(interner, self_ty), ..self } } @@ -896,11 +896,11 @@ pub struct HostEffectPredicate { impl Eq for HostEffectPredicate {} impl HostEffectPredicate { - pub fn self_ty(self) -> I::Ty { + pub fn self_ty(self) -> ty::Ty { self.trait_ref.self_ty() } - pub fn with_replaced_self_ty(self, interner: I, self_ty: I::Ty) -> Self { + pub fn with_replaced_self_ty(self, interner: I, self_ty: ty::Ty) -> Self { Self { trait_ref: self.trait_ref.with_replaced_self_ty(interner, self_ty), ..self } } @@ -915,7 +915,7 @@ impl ty::Binder> { self.skip_binder().def_id() } - pub fn self_ty(self) -> ty::Binder { + pub fn self_ty(self) -> ty::Binder> { self.map_bound(|trait_ref| trait_ref.self_ty()) } @@ -936,8 +936,8 @@ impl ty::Binder> { )] pub struct SubtypePredicate { pub a_is_expected: bool, - pub a: I::Ty, - pub b: I::Ty, + pub a: ty::Ty, + pub b: ty::Ty, } impl Eq for SubtypePredicate {} @@ -950,8 +950,8 @@ impl Eq for SubtypePredicate {} derive(Decodable_NoContext, Encodable_NoContext, HashStable_NoContext) )] pub struct CoercePredicate { - pub a: I::Ty, - pub b: I::Ty, + pub a: ty::Ty, + pub b: ty::Ty, } impl Eq for CoercePredicate {} diff --git a/compiler/rustc_type_ir/src/predicate_kind.rs b/compiler/rustc_type_ir/src/predicate_kind.rs index 445e85a888fca..b6ff27fb238e6 100644 --- a/compiler/rustc_type_ir/src/predicate_kind.rs +++ b/compiler/rustc_type_ir/src/predicate_kind.rs @@ -5,7 +5,7 @@ use derive_where::derive_where; use rustc_macros::{Decodable_NoContext, Encodable_NoContext, HashStable_NoContext}; use rustc_type_ir_macros::{GenericTypeVisitable, TypeFoldable_Generic, TypeVisitable_Generic}; -use crate::{self as ty, Interner}; +use crate::{self as ty, Interner, Ty}; /// A clause is something that can appear in where bounds or be inferred /// by implied bounds. @@ -25,7 +25,7 @@ pub enum ClauseKind { RegionOutlives(ty::OutlivesPredicate), /// `where T: 'r` - TypeOutlives(ty::OutlivesPredicate), + TypeOutlives(ty::OutlivesPredicate>), /// `where ::Name == X`, approximately. /// See the `ProjectionPredicate` struct for details. @@ -33,7 +33,7 @@ pub enum ClauseKind { /// Ensures that a const generic argument to a parameter `const N: u8` /// is of type `u8`. - ConstArgHasType(I::Const, I::Ty), + ConstArgHasType(I::Const, Ty), /// No syntax: `T` well-formed. WellFormed(I::Term), diff --git a/compiler/rustc_type_ir/src/relate.rs b/compiler/rustc_type_ir/src/relate.rs index d33c6036dadd8..31248bea4cf85 100644 --- a/compiler/rustc_type_ir/src/relate.rs +++ b/compiler/rustc_type_ir/src/relate.rs @@ -44,7 +44,7 @@ pub enum VarianceDiagInfo { Invariant { /// The generic type containing the generic parameter /// that changes the variance (e.g. `*mut T`, `MyStruct`) - ty: I::Ty, + ty: ty::Ty, /// The index of the generic parameter being used /// (e.g. `0` for `*mut T`, `1` for `MyStruct<'CovariantParam, 'InvariantParam>`) param_index: u32, @@ -75,13 +75,13 @@ pub trait TypeRelation: Sized { fn relate_ty_args( &mut self, - a_ty: I::Ty, - b_ty: I::Ty, + a_ty: ty::Ty, + b_ty: ty::Ty, ty_def_id: I::DefId, a_arg: I::GenericArgs, b_arg: I::GenericArgs, - mk: impl FnOnce(I::GenericArgs) -> I::Ty, - ) -> RelateResult; + mk: impl FnOnce(I::GenericArgs) -> ty::Ty, + ) -> RelateResult>; /// Switch variance for the purpose of relating `a` and `b`. fn relate_with_variance>( @@ -98,7 +98,7 @@ pub trait TypeRelation: Sized { // additional hooks for other types in the future if needed // without making older code, which called `relate`, obsolete. - fn tys(&mut self, a: I::Ty, b: I::Ty) -> RelateResult; + fn tys(&mut self, a: ty::Ty, b: ty::Ty) -> RelateResult>; fn regions(&mut self, a: I::Region, b: I::Region) -> RelateResult; @@ -332,9 +332,9 @@ impl Relate for ty::ExistentialTraitRef { #[instrument(level = "trace", skip(relation), ret)] pub fn structurally_relate_tys>( relation: &mut R, - a: I::Ty, - b: I::Ty, -) -> RelateResult { + a: ty::Ty, + b: ty::Ty, +) -> RelateResult> { let cx = relation.cx(); match (a.kind(), b.kind()) { (ty::Infer(_), _) | (_, ty::Infer(_)) => { diff --git a/compiler/rustc_type_ir/src/relate/combine.rs b/compiler/rustc_type_ir/src/relate/combine.rs index 64b87fac77f94..11fbbf89b9c7b 100644 --- a/compiler/rustc_type_ir/src/relate/combine.rs +++ b/compiler/rustc_type_ir/src/relate/combine.rs @@ -39,15 +39,15 @@ where ); /// Register `AliasRelate` obligation(s) that both types must be related to each other. - fn register_alias_relate_predicate(&mut self, a: I::Ty, b: I::Ty); + fn register_alias_relate_predicate(&mut self, a: ty::Ty, b: ty::Ty); } pub fn super_combine_tys( infcx: &Infcx, relation: &mut R, - a: I::Ty, - b: I::Ty, -) -> RelateResult + a: ty::Ty, + b: ty::Ty, +) -> RelateResult> where Infcx: InferCtxtLike, I: Interner, @@ -226,13 +226,13 @@ where pub fn combine_ty_args( infcx: &Infcx, relation: &mut R, - a_ty: I::Ty, - b_ty: I::Ty, + a_ty: ty::Ty, + b_ty: ty::Ty, variances: I::VariancesOf, a_args: I::GenericArgs, b_args: I::GenericArgs, - mk: impl FnOnce(I::GenericArgs) -> I::Ty, -) -> RelateResult + mk: impl FnOnce(I::GenericArgs) -> ty::Ty, +) -> RelateResult> where Infcx: InferCtxtLike, I: Interner, diff --git a/compiler/rustc_type_ir/src/relate/solver_relating.rs b/compiler/rustc_type_ir/src/relate/solver_relating.rs index 82ee4f75fcb0a..1494d67d3c603 100644 --- a/compiler/rustc_type_ir/src/relate/solver_relating.rs +++ b/compiler/rustc_type_ir/src/relate/solver_relating.rs @@ -5,7 +5,7 @@ use crate::data_structures::DelayedSet; use crate::relate::combine::combine_ty_args; pub use crate::relate::*; use crate::solve::Goal; -use crate::{self as ty, InferCtxtLike, Interner}; +use crate::{self as ty, InferCtxtLike, Interner, Ty}; pub trait RelateExt: InferCtxtLike { fn relate>( @@ -104,7 +104,7 @@ pub struct SolverRelating<'infcx, Infcx, I: Interner> { /// constrain `?1` to `u32`. When using the cache entry from the /// first time we've related these types, this only happens when /// later proving the `Subtype(?0, ?1)` goal from the first relation. - cache: DelayedSet<(ty::Variance, I::Ty, I::Ty)>, + cache: DelayedSet<(ty::Variance, Ty, Ty)>, } impl<'infcx, Infcx, I> SolverRelating<'infcx, Infcx, I> @@ -142,13 +142,13 @@ where fn relate_ty_args( &mut self, - a_ty: I::Ty, - b_ty: I::Ty, + a_ty: Ty, + b_ty: Ty, def_id: I::DefId, a_args: I::GenericArgs, b_args: I::GenericArgs, - _: impl FnOnce(I::GenericArgs) -> I::Ty, - ) -> RelateResult { + _: impl FnOnce(I::GenericArgs) -> Ty, + ) -> RelateResult> { if self.ambient_variance == ty::Invariant { // Avoid fetching the variance if we are in an invariant // context; no need, and it can induce dependency cycles @@ -178,7 +178,7 @@ where } #[instrument(skip(self), level = "trace")] - fn tys(&mut self, a: I::Ty, b: I::Ty) -> RelateResult { + fn tys(&mut self, a: Ty, b: Ty) -> RelateResult> { if a == b { return Ok(a); } @@ -383,7 +383,7 @@ where self.goals.extend(obligations); } - fn register_alias_relate_predicate(&mut self, a: I::Ty, b: I::Ty) { + fn register_alias_relate_predicate(&mut self, a: Ty, b: Ty) { self.register_predicates([ty::Binder::dummy(match self.ambient_variance { ty::Covariant => ty::PredicateKind::AliasRelate( a.into(), diff --git a/compiler/rustc_type_ir/src/solve/mod.rs b/compiler/rustc_type_ir/src/solve/mod.rs index 72b7df22b30d5..23e6075452b18 100644 --- a/compiler/rustc_type_ir/src/solve/mod.rs +++ b/compiler/rustc_type_ir/src/solve/mod.rs @@ -11,7 +11,7 @@ use rustc_type_ir_macros::{ use crate::lang_items::SolverTraitLangItem; use crate::search_graph::PathKind; -use crate::{self as ty, Canonical, CanonicalVarValues, Interner, Upcast}; +use crate::{self as ty, Canonical, CanonicalVarValues, Interner, Ty, Upcast}; pub type CanonicalInput::Predicate> = ty::CanonicalQueryInput>; @@ -254,7 +254,7 @@ impl Eq for Response {} #[cfg_attr(feature = "nightly", derive(HashStable_NoContext))] pub struct ExternalConstraintsData { pub region_constraints: Vec>, - pub opaque_types: Vec<(ty::OpaqueTypeKey, I::Ty)>, + pub opaque_types: Vec<(ty::OpaqueTypeKey, Ty)>, pub normalization_nested_goals: NestedNormalizationGoals, } diff --git a/compiler/rustc_type_ir/src/sty/mod.rs b/compiler/rustc_type_ir/src/sty/mod.rs new file mode 100644 index 0000000000000..5b73d372384b8 --- /dev/null +++ b/compiler/rustc_type_ir/src/sty/mod.rs @@ -0,0 +1,3 @@ +/// This type is temporary and exists to cut down the bloat of further PR's +/// moving `struct Ty` from `rustc_middle` to `rustc_type_ir`. +pub type Ty = ::Ty; diff --git a/compiler/rustc_type_ir/src/ty_kind.rs b/compiler/rustc_type_ir/src/ty_kind.rs index 983d8f0820b6b..24d28acc05e98 100644 --- a/compiler/rustc_type_ir/src/ty_kind.rs +++ b/compiler/rustc_type_ir/src/ty_kind.rs @@ -100,7 +100,7 @@ pub enum TyKind { Str, /// An array with the given length. Written as `[T; N]`. - Array(I::Ty, I::Const), + Array(ty::Ty, I::Const), /// A pattern newtype. /// @@ -109,17 +109,17 @@ pub enum TyKind { /// Only `Copy` and `Clone` will automatically get implemented for pattern types. /// Auto-traits treat this as if it were an aggregate with a single nested type. /// Only supports integer range patterns for now. - Pat(I::Ty, I::Pat), + Pat(ty::Ty, I::Pat), /// The pointee of an array slice. Written as `[T]`. - Slice(I::Ty), + Slice(ty::Ty), /// A raw pointer. Written as `*mut T` or `*const T` - RawPtr(I::Ty, Mutability), + RawPtr(ty::Ty, Mutability), /// A reference; a pointer with an associated lifetime. Written as /// `&'a mut T` or `&'a T`. - Ref(I::Region, I::Ty, Mutability), + Ref(I::Region, ty::Ty, Mutability), /// The anonymous type of a function declaration/definition. /// @@ -469,18 +469,18 @@ impl AliasTy { matches!(self.kind(interner), AliasTyKind::Opaque) } - pub fn to_ty(self, interner: I) -> I::Ty { + pub fn to_ty(self, interner: I) -> ty::Ty { Ty::new_alias(interner, self.kind(interner), self) } } /// The following methods work only with (trait) associated type projections. impl AliasTy { - pub fn self_ty(self) -> I::Ty { + pub fn self_ty(self) -> ty::Ty { self.args.type_at(0) } - pub fn with_replaced_self_ty(self, interner: I, self_ty: I::Ty) -> Self { + pub fn with_replaced_self_ty(self, interner: I, self_ty: ty::Ty) -> Self { AliasTy::new( interner, self.def_id, @@ -735,7 +735,7 @@ impl fmt::Debug for InferTy { )] #[derive(TypeVisitable_Generic, GenericTypeVisitable, TypeFoldable_Generic)] pub struct TypeAndMut { - pub ty: I::Ty, + pub ty: ty::Ty, pub mutbl: Mutability, } @@ -765,7 +765,7 @@ impl FnSig { self.inputs_and_output.inputs() } - pub fn output(self) -> I::Ty { + pub fn output(self) -> ty::Ty { self.inputs_and_output.output() } @@ -783,7 +783,7 @@ impl ty::Binder> { #[inline] #[track_caller] - pub fn input(self, index: usize) -> ty::Binder { + pub fn input(self, index: usize) -> ty::Binder> { self.map_bound(|fn_sig| fn_sig.inputs().get(index).unwrap()) } @@ -792,7 +792,7 @@ impl ty::Binder> { } #[inline] - pub fn output(self) -> ty::Binder { + pub fn output(self) -> ty::Binder> { self.map_bound(|fn_sig| fn_sig.output()) } @@ -856,21 +856,21 @@ impl fmt::Debug for FnSig { } // FIXME: this is a distinct type because we need to define `Encode`/`Decode` -// impls in this crate for `Binder`. +// impls in this crate for `Binder>`. #[derive_where(Clone, Copy, PartialEq, Hash; I: Interner)] #[cfg_attr(feature = "nightly", derive(HashStable_NoContext))] #[derive(TypeVisitable_Generic, GenericTypeVisitable, TypeFoldable_Generic, Lift_Generic)] -pub struct UnsafeBinderInner(ty::Binder); +pub struct UnsafeBinderInner(ty::Binder>); impl Eq for UnsafeBinderInner {} -impl From> for UnsafeBinderInner { - fn from(value: ty::Binder) -> Self { +impl From>> for UnsafeBinderInner { + fn from(value: ty::Binder>) -> Self { UnsafeBinderInner(value) } } -impl From> for ty::Binder { +impl From> for ty::Binder> { fn from(value: UnsafeBinderInner) -> Self { value.0 } @@ -883,7 +883,7 @@ impl fmt::Debug for UnsafeBinderInner { } impl Deref for UnsafeBinderInner { - type Target = ty::Binder; + type Target = ty::Binder>; fn deref(&self) -> &Self::Target { &self.0 @@ -894,7 +894,7 @@ impl Deref for UnsafeBinderInner { impl rustc_serialize::Encodable for UnsafeBinderInner where - I::Ty: rustc_serialize::Encodable, + ty::Ty: rustc_serialize::Encodable, I::BoundVarKinds: rustc_serialize::Encodable, { fn encode(&self, e: &mut E) { @@ -907,7 +907,7 @@ where impl rustc_serialize::Decodable for UnsafeBinderInner where - I::Ty: TypeVisitable + rustc_serialize::Decodable, + ty::Ty: TypeVisitable + rustc_serialize::Decodable, I::BoundVarKinds: rustc_serialize::Decodable, { fn decode(decoder: &mut D) -> Self { @@ -937,7 +937,7 @@ impl FnSigTys { self.inputs_and_output.inputs() } - pub fn output(self) -> I::Ty { + pub fn output(self) -> ty::Ty { self.inputs_and_output.output() } } @@ -960,7 +960,7 @@ impl ty::Binder> { #[inline] #[track_caller] - pub fn input(self, index: usize) -> ty::Binder { + pub fn input(self, index: usize) -> ty::Binder> { self.map_bound(|sig_tys| sig_tys.inputs().get(index).unwrap()) } @@ -969,7 +969,7 @@ impl ty::Binder> { } #[inline] - pub fn output(self) -> ty::Binder { + pub fn output(self) -> ty::Binder> { self.map_bound(|sig_tys| sig_tys.output()) } } diff --git a/compiler/rustc_type_ir/src/ty_kind/closure.rs b/compiler/rustc_type_ir/src/ty_kind/closure.rs index e8f94c8e7cc92..08c303b8de9c8 100644 --- a/compiler/rustc_type_ir/src/ty_kind/closure.rs +++ b/compiler/rustc_type_ir/src/ty_kind/closure.rs @@ -121,13 +121,13 @@ pub struct ClosureArgsParts { /// This is the args of the typeck root. pub parent_args: I::GenericArgsSlice, /// Represents the maximum calling capability of the closure. - pub closure_kind_ty: I::Ty, + pub closure_kind_ty: ty::Ty, /// Captures the closure's signature. This closure signature is "tupled", and /// thus has a peculiar signature of `extern "rust-call" fn((Args, ...)) -> Ty`. - pub closure_sig_as_fn_ptr_ty: I::Ty, + pub closure_sig_as_fn_ptr_ty: ty::Ty, /// The upvars captured by the closure. Remains an inference variable /// until the upvar analysis, which happens late in HIR typeck. - pub tupled_upvars_ty: I::Ty, + pub tupled_upvars_ty: ty::Ty, } impl ClosureArgs { @@ -169,14 +169,14 @@ impl ClosureArgs { /// Returns the tuple type representing the upvars for this closure. #[inline] - pub fn tupled_upvars_ty(self) -> I::Ty { + pub fn tupled_upvars_ty(self) -> ty::Ty { self.split().tupled_upvars_ty } /// Returns the closure kind for this closure; may return a type /// variable during inference. To get the closure kind during /// inference, use `infcx.closure_kind(args)`. - pub fn kind_ty(self) -> I::Ty { + pub fn kind_ty(self) -> ty::Ty { self.split().closure_kind_ty } @@ -185,7 +185,7 @@ impl ClosureArgs { // FIXME(eddyb) this should be unnecessary, as the shallowly resolved // type is known at the time of the creation of `ClosureArgs`, // see `rustc_hir_analysis::check::closure`. - pub fn sig_as_fn_ptr_ty(self) -> I::Ty { + pub fn sig_as_fn_ptr_ty(self) -> ty::Ty { self.split().closure_sig_as_fn_ptr_ty } @@ -223,7 +223,7 @@ pub struct CoroutineClosureArgsParts { /// This is the args of the typeck root. pub parent_args: I::GenericArgsSlice, /// Represents the maximum calling capability of the closure. - pub closure_kind_ty: I::Ty, + pub closure_kind_ty: ty::Ty, /// Represents all of the relevant parts of the coroutine returned by this /// coroutine-closure. This signature parts type will have the general /// shape of `fn(tupled_inputs, resume_ty) -> (return_ty, yield_ty)`, where @@ -232,10 +232,10 @@ pub struct CoroutineClosureArgsParts { /// /// Use `coroutine_closure_sig` to break up this type rather than using it /// yourself. - pub signature_parts_ty: I::Ty, + pub signature_parts_ty: ty::Ty, /// The upvars captured by the closure. Remains an inference variable /// until the upvar analysis, which happens late in HIR typeck. - pub tupled_upvars_ty: I::Ty, + pub tupled_upvars_ty: ty::Ty, /// a function pointer that has the shape `for<'env> fn() -> (&'env T, ...)`. /// This allows us to represent the binder of the self-captures of the closure. /// @@ -243,7 +243,7 @@ pub struct CoroutineClosureArgsParts { /// from the closure's upvars, this will be `for<'env> fn() -> (&'env String,)`, /// while the `tupled_upvars_ty`, representing the by-move version of the same /// captures, will be `(String,)`. - pub coroutine_captures_by_ref_ty: I::Ty, + pub coroutine_captures_by_ref_ty: ty::Ty, } impl CoroutineClosureArgs { @@ -277,11 +277,11 @@ impl CoroutineClosureArgs { } #[inline] - pub fn tupled_upvars_ty(self) -> I::Ty { + pub fn tupled_upvars_ty(self) -> ty::Ty { self.split().tupled_upvars_ty } - pub fn kind_ty(self) -> I::Ty { + pub fn kind_ty(self) -> ty::Ty { self.split().closure_kind_ty } @@ -289,7 +289,7 @@ impl CoroutineClosureArgs { self.kind_ty().to_opt_closure_kind().unwrap() } - pub fn signature_parts_ty(self) -> I::Ty { + pub fn signature_parts_ty(self) -> ty::Ty { self.split().signature_parts_ty } @@ -314,7 +314,7 @@ impl CoroutineClosureArgs { }) } - pub fn coroutine_captures_by_ref_ty(self) -> I::Ty { + pub fn coroutine_captures_by_ref_ty(self) -> ty::Ty { self.split().coroutine_captures_by_ref_ty } @@ -358,10 +358,10 @@ impl TypeVisitor for HasRegionsBoundAt { #[derive_where(Clone, Copy, PartialEq, Hash, Debug; I: Interner)] #[derive(TypeVisitable_Generic, GenericTypeVisitable, TypeFoldable_Generic)] pub struct CoroutineClosureSignature { - pub tupled_inputs_ty: I::Ty, - pub resume_ty: I::Ty, - pub yield_ty: I::Ty, - pub return_ty: I::Ty, + pub tupled_inputs_ty: ty::Ty, + pub resume_ty: ty::Ty, + pub yield_ty: ty::Ty, + pub return_ty: ty::Ty, // Like the `fn_sig_as_fn_ptr_ty` of a regular closure, these types // never actually differ. But we save them rather than recreating them @@ -393,10 +393,10 @@ impl CoroutineClosureSignature { self, cx: I, parent_args: I::GenericArgsSlice, - coroutine_kind_ty: I::Ty, + coroutine_kind_ty: ty::Ty, coroutine_def_id: I::CoroutineId, - tupled_upvars_ty: I::Ty, - ) -> I::Ty { + tupled_upvars_ty: ty::Ty, + ) -> ty::Ty { let coroutine_args = ty::CoroutineArgs::new( cx, ty::CoroutineArgsParts { @@ -424,9 +424,9 @@ impl CoroutineClosureSignature { coroutine_def_id: I::CoroutineId, goal_kind: ty::ClosureKind, env_region: I::Region, - closure_tupled_upvars_ty: I::Ty, - coroutine_captures_by_ref_ty: I::Ty, - ) -> I::Ty { + closure_tupled_upvars_ty: ty::Ty, + coroutine_captures_by_ref_ty: ty::Ty, + ) -> ty::Ty { let tupled_upvars_ty = Self::tupled_upvars_by_closure_kind( cx, goal_kind, @@ -457,11 +457,11 @@ impl CoroutineClosureSignature { pub fn tupled_upvars_by_closure_kind( cx: I, kind: ty::ClosureKind, - tupled_inputs_ty: I::Ty, - closure_tupled_upvars_ty: I::Ty, - coroutine_captures_by_ref_ty: I::Ty, + tupled_inputs_ty: ty::Ty, + closure_tupled_upvars_ty: ty::Ty, + coroutine_captures_by_ref_ty: ty::Ty, env_region: I::Region, - ) -> I::Ty { + ) -> ty::Ty { match kind { ty::ClosureKind::Fn | ty::ClosureKind::FnMut => { let ty::FnPtr(sig_tys, _) = coroutine_captures_by_ref_ty.kind() else { @@ -503,7 +503,7 @@ struct FoldEscapingRegions { // Depends on `debruijn` because we may have types with regions of different // debruijn depths depending on the binders we've entered. - cache: DelayedMap<(ty::DebruijnIndex, I::Ty), I::Ty>, + cache: DelayedMap<(ty::DebruijnIndex, ty::Ty), ty::Ty>, } impl TypeFolder for FoldEscapingRegions { @@ -511,7 +511,7 @@ impl TypeFolder for FoldEscapingRegions { self.interner } - fn fold_ty(&mut self, t: I::Ty) -> I::Ty { + fn fold_ty(&mut self, t: ty::Ty) -> ty::Ty { if !t.has_vars_bound_at_or_above(self.debruijn) { t } else if let Some(&t) = self.cache.get(&(self.debruijn, t)) { @@ -553,9 +553,9 @@ impl TypeFolder for FoldEscapingRegions { #[derive_where(Clone, Copy, PartialEq, Hash, Debug; I: Interner)] #[derive(TypeVisitable_Generic, GenericTypeVisitable, TypeFoldable_Generic)] pub struct GenSig { - pub resume_ty: I::Ty, - pub yield_ty: I::Ty, - pub return_ty: I::Ty, + pub resume_ty: ty::Ty, + pub yield_ty: ty::Ty, + pub return_ty: ty::Ty, } impl Eq for GenSig {} @@ -581,15 +581,15 @@ pub struct CoroutineArgsParts { /// kind: `i8`/`i16`/`i32`. /// /// For regular coroutines, this field will always just be `()`. - pub kind_ty: I::Ty, + pub kind_ty: ty::Ty, - pub resume_ty: I::Ty, - pub yield_ty: I::Ty, - pub return_ty: I::Ty, + pub resume_ty: ty::Ty, + pub yield_ty: ty::Ty, + pub return_ty: ty::Ty, /// The upvars captured by the closure. Remains an inference variable /// until the upvar analysis, which happens late in HIR typeck. - pub tupled_upvars_ty: I::Ty, + pub tupled_upvars_ty: ty::Ty, } impl CoroutineArgs { @@ -619,7 +619,7 @@ impl CoroutineArgs { } // Returns the kind of the coroutine. See docs on the `kind_ty` field. - pub fn kind_ty(self) -> I::Ty { + pub fn kind_ty(self) -> ty::Ty { self.split().kind_ty } @@ -638,22 +638,22 @@ impl CoroutineArgs { /// Returns the tuple type representing the upvars for this coroutine. #[inline] - pub fn tupled_upvars_ty(self) -> I::Ty { + pub fn tupled_upvars_ty(self) -> ty::Ty { self.split().tupled_upvars_ty } /// Returns the type representing the resume type of the coroutine. - pub fn resume_ty(self) -> I::Ty { + pub fn resume_ty(self) -> ty::Ty { self.split().resume_ty } /// Returns the type representing the yield type of the coroutine. - pub fn yield_ty(self) -> I::Ty { + pub fn yield_ty(self) -> ty::Ty { self.split().yield_ty } /// Returns the type representing the return type of the coroutine. - pub fn return_ty(self) -> I::Ty { + pub fn return_ty(self) -> ty::Ty { self.split().return_ty } diff --git a/compiler/rustc_type_ir/src/visit.rs b/compiler/rustc_type_ir/src/visit.rs index 6e62e1031a969..1ee4bff6b7a11 100644 --- a/compiler/rustc_type_ir/src/visit.rs +++ b/compiler/rustc_type_ir/src/visit.rs @@ -52,7 +52,7 @@ use smallvec::SmallVec; use thin_vec::ThinVec; use crate::inherent::*; -use crate::{self as ty, Interner, TypeFlags}; +use crate::{self as ty, Interner, Ty, TypeFlags}; /// This trait is implemented for every type that can be visited, /// providing the skeleton of the traversal. @@ -98,7 +98,7 @@ pub trait TypeVisitor: Sized { t.super_visit_with(self) } - fn visit_ty(&mut self, t: I::Ty) -> Self::Result { + fn visit_ty(&mut self, t: Ty) -> Self::Result { t.super_visit_with(self) } @@ -417,7 +417,7 @@ impl TypeVisitor for HasTypeFlagsVisitor { } #[inline] - fn visit_ty(&mut self, t: I::Ty) -> Self::Result { + fn visit_ty(&mut self, t: Ty) -> Self::Result { // Note: no `super_visit_with` call. let flags = t.flags(); if flags.intersects(self.flags) { @@ -522,7 +522,7 @@ impl TypeVisitor for HasEscapingVarsVisitor { } #[inline] - fn visit_ty(&mut self, t: I::Ty) -> Self::Result { + fn visit_ty(&mut self, t: Ty) -> Self::Result { // If the outer-exclusive-binder is *strictly greater* than // `outer_index`, that means that `t` contains some content // bound at `outer_index` or above (because From fe4e53ebf240e2a0d06a02813bb9ba379080a90c Mon Sep 17 00:00:00 2001 From: Sasha Pourcelot Date: Sun, 29 Mar 2026 10:03:53 +0000 Subject: [PATCH 08/20] extract AttributeParseError rendering code into smaller subfunctions --- .../src/session_diagnostics.rs | 139 +++++++++++------- 1 file changed, 84 insertions(+), 55 deletions(-) diff --git a/compiler/rustc_attr_parsing/src/session_diagnostics.rs b/compiler/rustc_attr_parsing/src/session_diagnostics.rs index bab830098f1a8..c95245707ece6 100644 --- a/compiler/rustc_attr_parsing/src/session_diagnostics.rs +++ b/compiler/rustc_attr_parsing/src/session_diagnostics.rs @@ -594,19 +594,96 @@ pub(crate) struct AttributeParseError<'a> { pub(crate) suggestions: Vec, } +impl<'a> AttributeParseError<'a> { + fn render_expected_specific_argument( + &self, + diag: &mut Diag<'_, G>, + possibilities: &[Symbol], + strings: bool, + ) where + G: EmissionGuarantee, + { + let quote = if strings { '"' } else { '`' }; + match possibilities { + &[] => {} + &[x] => { + diag.span_label( + self.span, + format!("the only valid argument here is {quote}{x}{quote}"), + ); + } + [first, second] => { + diag.span_label( + self.span, + format!("valid arguments are {quote}{first}{quote} or {quote}{second}{quote}"), + ); + } + [first @ .., second_to_last, last] => { + let mut res = String::new(); + for i in first { + res.push_str(&format!("{quote}{i}{quote}, ")); + } + res.push_str(&format!("{quote}{second_to_last}{quote} or {quote}{last}{quote}")); + + diag.span_label(self.span, format!("valid arguments are {res}")); + } + } + } + + fn render_expected_specific_argument_list( + &self, + diag: &mut Diag<'_, G>, + possibilities: &[Symbol], + strings: bool, + ) where + G: EmissionGuarantee, + { + let description = self.description(); + + let quote = if strings { '"' } else { '`' }; + match possibilities { + &[] => {} + &[x] => { + diag.span_label( + self.span, + format!( + "this {description} is only valid with {quote}{x}{quote} as an argument" + ), + ); + } + [first, second] => { + diag.span_label(self.span, format!("this {description} is only valid with either {quote}{first}{quote} or {quote}{second}{quote} as an argument")); + } + [first @ .., second_to_last, last] => { + let mut res = String::new(); + for i in first { + res.push_str(&format!("{quote}{i}{quote}, ")); + } + res.push_str(&format!("{quote}{second_to_last}{quote} or {quote}{last}{quote}")); + + diag.span_label(self.span, format!("this {description} is only valid with one of the following arguments: {res}")); + } + } + } + + fn description(&self) -> &'static str { + match self.description { + ParsedDescription::Attribute => "attribute", + ParsedDescription::Macro => "macro", + } + } +} + impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for AttributeParseError<'_> { fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> { let name = self.path.to_string(); - let description = match self.description { - ParsedDescription::Attribute => "attribute", - ParsedDescription::Macro => "macro", - }; + let description = self.description(); let mut diag = Diag::new(dcx, level, format!("malformed `{name}` {description} input")); diag.span(self.attr_span); diag.code(E0539); - match self.reason { + match &self.reason { AttributeParseErrorReason::ExpectedStringLiteral { byte_string } => { if let Some(start_point_span) = byte_string { diag.span_suggestion( @@ -693,62 +770,14 @@ impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for AttributeParseError<'_> { strings, list: false, } => { - let quote = if strings { '"' } else { '`' }; - match possibilities { - &[] => {} - &[x] => { - diag.span_label( - self.span, - format!("the only valid argument here is {quote}{x}{quote}"), - ); - } - [first, second] => { - diag.span_label(self.span, format!("valid arguments are {quote}{first}{quote} or {quote}{second}{quote}")); - } - [first @ .., second_to_last, last] => { - let mut res = String::new(); - for i in first { - res.push_str(&format!("{quote}{i}{quote}, ")); - } - res.push_str(&format!( - "{quote}{second_to_last}{quote} or {quote}{last}{quote}" - )); - - diag.span_label(self.span, format!("valid arguments are {res}")); - } - } + self.render_expected_specific_argument(&mut diag, *possibilities, *strings); } AttributeParseErrorReason::ExpectedSpecificArgument { possibilities, strings, list: true, } => { - let quote = if strings { '"' } else { '`' }; - match possibilities { - &[] => {} - &[x] => { - diag.span_label( - self.span, - format!( - "this {description} is only valid with {quote}{x}{quote} as an argument" - ), - ); - } - [first, second] => { - diag.span_label(self.span, format!("this {description} is only valid with either {quote}{first}{quote} or {quote}{second}{quote} as an argument")); - } - [first @ .., second_to_last, last] => { - let mut res = String::new(); - for i in first { - res.push_str(&format!("{quote}{i}{quote}, ")); - } - res.push_str(&format!( - "{quote}{second_to_last}{quote} or {quote}{last}{quote}" - )); - - diag.span_label(self.span, format!("this {description} is only valid with one of the following arguments: {res}")); - } - } + self.render_expected_specific_argument_list(&mut diag, *possibilities, *strings); } AttributeParseErrorReason::ExpectedIdentifier => { diag.span_label(self.span, "expected a valid identifier here"); From bb40df6e560bb892aa7768faadf53946438017dd Mon Sep 17 00:00:00 2001 From: Sasha Pourcelot Date: Sun, 29 Mar 2026 10:03:53 +0000 Subject: [PATCH 09/20] document why it is important to early return on ExpectedStringLiteral --- compiler/rustc_attr_parsing/src/session_diagnostics.rs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/compiler/rustc_attr_parsing/src/session_diagnostics.rs b/compiler/rustc_attr_parsing/src/session_diagnostics.rs index c95245707ece6..7321260972157 100644 --- a/compiler/rustc_attr_parsing/src/session_diagnostics.rs +++ b/compiler/rustc_attr_parsing/src/session_diagnostics.rs @@ -687,13 +687,15 @@ impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for AttributeParseError<'_> { AttributeParseErrorReason::ExpectedStringLiteral { byte_string } => { if let Some(start_point_span) = byte_string { diag.span_suggestion( - start_point_span, + *start_point_span, "consider removing the prefix", "", Applicability::MaybeIncorrect, ); diag.note("expected a normal string literal, not a byte string literal"); + // Avoid emitting an "attribute must be of the form" suggestion, as the + // attribute is likely to be well-formed already. return diag; } else { diag.span_label(self.span, "expected a string literal here"); From 61ea83db4197587424b7a2c5c3c0a792b9e36188 Mon Sep 17 00:00:00 2001 From: cyrgani Date: Mon, 30 Mar 2026 20:39:42 +0000 Subject: [PATCH 10/20] delete some duplicated tests --- tests/ui/associated-types/issue-47814.rs | 13 ------------- tests/ui/associated-types/issue-47814.stderr | 14 -------------- tests/ui/fn/issue-1900.rs | 2 -- tests/ui/fn/issue-1900.stderr | 9 --------- .../specialization-feature-gate-default.rs | 11 ----------- .../specialization-feature-gate-default.stderr | 15 --------------- 6 files changed, 64 deletions(-) delete mode 100644 tests/ui/associated-types/issue-47814.rs delete mode 100644 tests/ui/associated-types/issue-47814.stderr delete mode 100644 tests/ui/fn/issue-1900.rs delete mode 100644 tests/ui/fn/issue-1900.stderr delete mode 100644 tests/ui/specialization/defaultimpl/specialization-feature-gate-default.rs delete mode 100644 tests/ui/specialization/defaultimpl/specialization-feature-gate-default.stderr diff --git a/tests/ui/associated-types/issue-47814.rs b/tests/ui/associated-types/issue-47814.rs deleted file mode 100644 index 90e8a3bc2f2f4..0000000000000 --- a/tests/ui/associated-types/issue-47814.rs +++ /dev/null @@ -1,13 +0,0 @@ -struct ArpIPv4<'a> { - s: &'a u8 -} - -impl<'a> ArpIPv4<'a> { - const LENGTH: usize = 20; - - pub fn to_buffer() -> [u8; Self::LENGTH] { //~ ERROR generic `Self` types are currently not permitted in anonymous constants - unimplemented!() - } -} - -pub fn main() {} diff --git a/tests/ui/associated-types/issue-47814.stderr b/tests/ui/associated-types/issue-47814.stderr deleted file mode 100644 index 7382426b0ffaa..0000000000000 --- a/tests/ui/associated-types/issue-47814.stderr +++ /dev/null @@ -1,14 +0,0 @@ -error: generic `Self` types are currently not permitted in anonymous constants - --> $DIR/issue-47814.rs:8:32 - | -LL | pub fn to_buffer() -> [u8; Self::LENGTH] { - | ^^^^ - | -note: not a concrete type - --> $DIR/issue-47814.rs:5:10 - | -LL | impl<'a> ArpIPv4<'a> { - | ^^^^^^^^^^^ - -error: aborting due to 1 previous error - diff --git a/tests/ui/fn/issue-1900.rs b/tests/ui/fn/issue-1900.rs deleted file mode 100644 index 761bd3170270c..0000000000000 --- a/tests/ui/fn/issue-1900.rs +++ /dev/null @@ -1,2 +0,0 @@ -fn main() { } -//~^ ERROR `main` function is not allowed to have generic parameters diff --git a/tests/ui/fn/issue-1900.stderr b/tests/ui/fn/issue-1900.stderr deleted file mode 100644 index 31fd46c8e2a53..0000000000000 --- a/tests/ui/fn/issue-1900.stderr +++ /dev/null @@ -1,9 +0,0 @@ -error[E0131]: `main` function is not allowed to have generic parameters - --> $DIR/issue-1900.rs:1:8 - | -LL | fn main() { } - | ^^^ `main` cannot have generic parameters - -error: aborting due to 1 previous error - -For more information about this error, try `rustc --explain E0131`. diff --git a/tests/ui/specialization/defaultimpl/specialization-feature-gate-default.rs b/tests/ui/specialization/defaultimpl/specialization-feature-gate-default.rs deleted file mode 100644 index 89158b65a6e29..0000000000000 --- a/tests/ui/specialization/defaultimpl/specialization-feature-gate-default.rs +++ /dev/null @@ -1,11 +0,0 @@ -// Check that specialization must be ungated to use the `default` keyword - -trait Foo { - fn foo(&self); -} - -default impl Foo for T { //~ ERROR specialization is unstable - fn foo(&self) {} -} - -fn main() {} diff --git a/tests/ui/specialization/defaultimpl/specialization-feature-gate-default.stderr b/tests/ui/specialization/defaultimpl/specialization-feature-gate-default.stderr deleted file mode 100644 index e28d9c9fa836f..0000000000000 --- a/tests/ui/specialization/defaultimpl/specialization-feature-gate-default.stderr +++ /dev/null @@ -1,15 +0,0 @@ -error[E0658]: specialization is unstable - --> $DIR/specialization-feature-gate-default.rs:7:1 - | -LL | / default impl Foo for T { -LL | | fn foo(&self) {} -LL | | } - | |_^ - | - = note: see issue #31844 for more information - = help: add `#![feature(specialization)]` to the crate attributes to enable - = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date - -error: aborting due to 1 previous error - -For more information about this error, try `rustc --explain E0658`. From d24ebcb47c36519b259a706e0cf3d80bcd293aea Mon Sep 17 00:00:00 2001 From: cyrgani Date: Mon, 30 Mar 2026 20:40:15 +0000 Subject: [PATCH 11/20] rename some `issues-*` tests --- src/tools/tidy/src/issues.txt | 3 --- .../{issue-78720.rs => nested-copy-drops-83176.rs} | 1 + .../{issue-78720.stderr => nested-copy-drops-83176.stderr} | 2 +- tests/ui/impl-trait/rpit/unit-impl-default-36379.rs | 6 ++++++ tests/ui/issues/issue-36379.rs | 5 ----- 5 files changed, 8 insertions(+), 9 deletions(-) rename tests/ui/closures/2229_closure_analysis/migrations/{issue-78720.rs => nested-copy-drops-83176.rs} (77%) rename tests/ui/closures/2229_closure_analysis/migrations/{issue-78720.stderr => nested-copy-drops-83176.stderr} (88%) create mode 100644 tests/ui/impl-trait/rpit/unit-impl-default-36379.rs delete mode 100644 tests/ui/issues/issue-36379.rs diff --git a/src/tools/tidy/src/issues.txt b/src/tools/tidy/src/issues.txt index f382502c7068b..3b23fe5d80826 100644 --- a/src/tools/tidy/src/issues.txt +++ b/src/tools/tidy/src/issues.txt @@ -117,7 +117,6 @@ ui/associated-types/issue-44153.rs ui/associated-types/issue-47139-1.rs ui/associated-types/issue-47139-2.rs ui/associated-types/issue-47385.rs -ui/associated-types/issue-47814.rs ui/associated-types/issue-48010.rs ui/associated-types/issue-48551.rs ui/associated-types/issue-50301.rs @@ -406,7 +405,6 @@ ui/closures/2229_closure_analysis/match/issue-87097.rs ui/closures/2229_closure_analysis/match/issue-87426.rs ui/closures/2229_closure_analysis/match/issue-87988.rs ui/closures/2229_closure_analysis/match/issue-88331.rs -ui/closures/2229_closure_analysis/migrations/issue-78720.rs ui/closures/2229_closure_analysis/migrations/issue-86753.rs ui/closures/2229_closure_analysis/migrations/issue-90024-adt-correct-subst.rs ui/closures/2229_closure_analysis/run_pass/issue-87378.rs @@ -1001,7 +999,6 @@ ui/fmt/issue-86085.rs ui/fmt/issue-89173.rs ui/fmt/issue-91556.rs ui/fn/issue-1451.rs -ui/fn/issue-1900.rs ui/fn/issue-3044.rs ui/fn/issue-3099.rs ui/fn/issue-3904.rs diff --git a/tests/ui/closures/2229_closure_analysis/migrations/issue-78720.rs b/tests/ui/closures/2229_closure_analysis/migrations/nested-copy-drops-83176.rs similarity index 77% rename from tests/ui/closures/2229_closure_analysis/migrations/issue-78720.rs rename to tests/ui/closures/2229_closure_analysis/migrations/nested-copy-drops-83176.rs index 3e72eec4ea8c6..2df8931f7ef7a 100644 --- a/tests/ui/closures/2229_closure_analysis/migrations/issue-78720.rs +++ b/tests/ui/closures/2229_closure_analysis/migrations/nested-copy-drops-83176.rs @@ -1,3 +1,4 @@ +// Regression test for https://github.com/rust-lang/rust/issues/83176. //@ run-pass #![warn(rust_2021_incompatible_closure_captures)] diff --git a/tests/ui/closures/2229_closure_analysis/migrations/issue-78720.stderr b/tests/ui/closures/2229_closure_analysis/migrations/nested-copy-drops-83176.stderr similarity index 88% rename from tests/ui/closures/2229_closure_analysis/migrations/issue-78720.stderr rename to tests/ui/closures/2229_closure_analysis/migrations/nested-copy-drops-83176.stderr index 2609e2951ec54..595173b49da68 100644 --- a/tests/ui/closures/2229_closure_analysis/migrations/issue-78720.stderr +++ b/tests/ui/closures/2229_closure_analysis/migrations/nested-copy-drops-83176.stderr @@ -1,5 +1,5 @@ warning: irrefutable `if let` pattern - --> $DIR/issue-78720.rs:7:8 + --> $DIR/nested-copy-drops-83176.rs:8:8 | LL | if let a = "" { | ^^^^^^^^^^ diff --git a/tests/ui/impl-trait/rpit/unit-impl-default-36379.rs b/tests/ui/impl-trait/rpit/unit-impl-default-36379.rs new file mode 100644 index 0000000000000..43c93065739d3 --- /dev/null +++ b/tests/ui/impl-trait/rpit/unit-impl-default-36379.rs @@ -0,0 +1,6 @@ +//! Regression test for https://github.com/rust-lang/rust/issues/36379 +//@ check-pass + +fn _test() -> impl Default { } + +fn main() {} diff --git a/tests/ui/issues/issue-36379.rs b/tests/ui/issues/issue-36379.rs deleted file mode 100644 index 6e275b03a7029..0000000000000 --- a/tests/ui/issues/issue-36379.rs +++ /dev/null @@ -1,5 +0,0 @@ -//@ check-pass - -fn _test() -> impl Default { } - -fn main() {} From 6cd26567db61c85479cdf6192a18f6d6bce43ca8 Mon Sep 17 00:00:00 2001 From: cyrgani Date: Mon, 30 Mar 2026 20:40:27 +0000 Subject: [PATCH 12/20] add more FIXMEs and details to `ui/README.md` --- tests/ui/README.md | 28 ++++++++++++++++++++++------ 1 file changed, 22 insertions(+), 6 deletions(-) diff --git a/tests/ui/README.md b/tests/ui/README.md index eb14039d8151a..a9e7f022c2b60 100644 --- a/tests/ui/README.md +++ b/tests/ui/README.md @@ -36,6 +36,8 @@ These tests exercise the [`annotate-snippets`]-based emitter implementation. [`annotate-snippets`]: https://github.com/rust-lang/annotate-snippets-rs +**FIXME**: merge this with `error-emitter` + ## `tests/ui/anon-params` These tests deal with anonymous parameters (no name, only type), a deprecated feature that becomes a hard error in Edition 2018. @@ -141,6 +143,8 @@ However, only a single test was ever added to this category: . @@ -730,6 +734,8 @@ Tests on type inference. Tests for diagnostics on infinitely recursive types without indirection. +**FIXME**: check for overlap with `structs-enums/enum-rec` and `structs-enums/struct-rec` + ## `tests/ui/inline-const/` These tests revolve around the inline `const` block that forces the compiler to const-eval its content. @@ -853,7 +859,9 @@ Tests exercising analysis for unused variables, unreachable statements, function ## `tests/ui/loop-match` -Tests for `loop` with `match` expressions. +Tests for the `loop_match` feature to optimize `loop`s consisting of one big `match` expressions. + +See [Tracking issue for way to express intraprocedural finite state machines #132306](https://github.com/rust-lang/rust/issues/132306). ## `tests/ui/loops/` @@ -891,6 +899,8 @@ See [Tracking issue for allowing overlapping implementations for marker trait #2 Broad category of tests on `match` constructs. +**FIXME**: many tests overlap with `tests/ui/bindings`, try to reduce duplication. + ## `tests/ui/methods/` A broad category for anything related to methods and method resolution. @@ -899,6 +909,8 @@ A broad category for anything related to methods and method resolution. Certain mir-opt regression tests. +**FIXME**: many tests in this directory are not about MIR or optimizations, relocate these. + ## `tests/ui/mir-dataflow` Tests for MIR dataflow analysis. @@ -977,6 +989,8 @@ Tests that exercises edge cases, such as specific floats, large or very small nu Tests that checks numeric types and their interactions, such as casting among them with `as` or providing the wrong numeric suffix. +**FIXME**: these tests could get moved to other directories, in particular `cast/` or `parser/`. + ## `tests/ui/object-lifetime/` Tests on lifetimes on objects, such as a lifetime bound not being able to be deduced from context, or checking that lifetimes are inherited properly. @@ -1308,7 +1322,7 @@ Some standard library tests which are too inconvenient or annoying to implement ## `tests/ui/str/` -Exercise `str` keyword and string slices. +Exercise `str` primitive and string slices. ## `tests/ui/structs/` @@ -1464,6 +1478,8 @@ See [RFC 0132 Unified Function Call Syntax](https://github.com/rust-lang/rfcs/bl `#![feature(unboxed_closures)]`, `Fn`, `FnMut` and `FnOnce` traits +**FIXME**: many tests have `unboxed-closure` in their name but only test normal closures, rename these. + See [Tracking issue for Fn traits (`unboxed_closures` & `fn_traits` feature)](https://github.com/rust-lang/rust/issues/29625). ## `tests/ui/underscore-lifetime/`: `'_` elided lifetime From 2d87df126960770259499fffc0afcbc262c06944 Mon Sep 17 00:00:00 2001 From: Jacob Adam Date: Tue, 31 Mar 2026 00:08:31 +0100 Subject: [PATCH 13/20] Add a test for a now fixed ICE with `offset_of!()` --- ...f-unsized-trait-object-missing-lifetime.rs | 20 ++++++++++++++ ...sized-trait-object-missing-lifetime.stderr | 27 +++++++++++++++++++ 2 files changed, 47 insertions(+) create mode 100644 tests/ui/offset-of/offset-of-unsized-trait-object-missing-lifetime.rs create mode 100644 tests/ui/offset-of/offset-of-unsized-trait-object-missing-lifetime.stderr diff --git a/tests/ui/offset-of/offset-of-unsized-trait-object-missing-lifetime.rs b/tests/ui/offset-of/offset-of-unsized-trait-object-missing-lifetime.rs new file mode 100644 index 0000000000000..b28e093662350 --- /dev/null +++ b/tests/ui/offset-of/offset-of-unsized-trait-object-missing-lifetime.rs @@ -0,0 +1,20 @@ +//@ edition:2021 +// Regression test for #125805. +// ICE when using `offset_of!` on a field whose type is a bare trait object +// with a missing lifetime parameter. + +trait X<'a> {} + +use std::mem::offset_of; + +struct T { + y: X, + //~^ ERROR missing lifetime specifier [E0106] + //~| ERROR expected a type, found a trait [E0782] +} + +fn other() { + offset_of!(T, y); +} + +fn main() {} diff --git a/tests/ui/offset-of/offset-of-unsized-trait-object-missing-lifetime.stderr b/tests/ui/offset-of/offset-of-unsized-trait-object-missing-lifetime.stderr new file mode 100644 index 0000000000000..7f4a370d86d80 --- /dev/null +++ b/tests/ui/offset-of/offset-of-unsized-trait-object-missing-lifetime.stderr @@ -0,0 +1,27 @@ +error[E0106]: missing lifetime specifier + --> $DIR/offset-of-unsized-trait-object-missing-lifetime.rs:11:8 + | +LL | y: X, + | ^ expected named lifetime parameter + | +help: consider introducing a named lifetime parameter + | +LL ~ struct T<'a> { +LL ~ y: X<'a>, + | + +error[E0782]: expected a type, found a trait + --> $DIR/offset-of-unsized-trait-object-missing-lifetime.rs:11:8 + | +LL | y: X, + | ^ + | +help: you can add the `dyn` keyword if you want a trait object + | +LL | y: dyn X, + | +++ + +error: aborting due to 2 previous errors + +Some errors have detailed explanations: E0106, E0782. +For more information about an error, try `rustc --explain E0106`. From 4ca5c07a1b117fbd183b439a658f26b00bec760b Mon Sep 17 00:00:00 2001 From: Josh Triplett Date: Mon, 30 Mar 2026 18:14:29 -0700 Subject: [PATCH 14/20] build-manifest: Use zlib-rs --- src/tools/build-manifest/Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/tools/build-manifest/Cargo.toml b/src/tools/build-manifest/Cargo.toml index 2b0afae76da42..0b766a3e557c5 100644 --- a/src/tools/build-manifest/Cargo.toml +++ b/src/tools/build-manifest/Cargo.toml @@ -8,7 +8,7 @@ toml = "0.7" serde = { version = "1.0", features = ["derive"] } serde_json = "1.0" anyhow = "1.0.32" -flate2 = "1.0.26" +flate2 = { version = "1.1.9", default-features = false, features = ["zlib-rs"] } xz2 = "0.1.7" tar = "0.4.45" sha2 = "0.10.1" From 3d1fb4c1b337f0edf7199974a0f91182c422d19d Mon Sep 17 00:00:00 2001 From: Josh Triplett Date: Mon, 30 Mar 2026 18:14:57 -0700 Subject: [PATCH 15/20] rust-installer: Use zlib-rs --- src/tools/rust-installer/Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/tools/rust-installer/Cargo.toml b/src/tools/rust-installer/Cargo.toml index e0c93e3c4477b..0cb9fa76b2f9e 100644 --- a/src/tools/rust-installer/Cargo.toml +++ b/src/tools/rust-installer/Cargo.toml @@ -11,7 +11,7 @@ path = "src/main.rs" [dependencies] anyhow = "1.0.19" -flate2 = "1.0.1" +flate2 = { version = "1.1.9", default-features = false, features = ["zlib-rs"] } rayon = "1.0" tar = "0.4.45" walkdir = "2" From 1a67e2be36e50967ea962d90364b6b150055a966 Mon Sep 17 00:00:00 2001 From: Crystal Durham Date: Mon, 30 Mar 2026 21:33:53 -0400 Subject: [PATCH 16/20] Fix AtomicPtr::update's cfg gate --- library/core/src/sync/atomic.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/core/src/sync/atomic.rs b/library/core/src/sync/atomic.rs index 0077b5b9d31b7..004772267da74 100644 --- a/library/core/src/sync/atomic.rs +++ b/library/core/src/sync/atomic.rs @@ -2136,7 +2136,7 @@ impl AtomicPtr { /// ``` #[inline] #[stable(feature = "atomic_try_update", since = "1.95.0")] - #[cfg(target_has_atomic = "8")] + #[cfg(target_has_atomic = "ptr")] #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces #[rustc_should_not_be_called_on_const_items] pub fn update( From 722b2d36269b9dea4893a6ecd55cde31b2df9991 Mon Sep 17 00:00:00 2001 From: Josh Triplett Date: Mon, 30 Mar 2026 18:43:16 -0700 Subject: [PATCH 17/20] Cargo.lock: Update for zlib-rs --- Cargo.lock | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index d4c1a02c018af..c1c592da7767f 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1422,12 +1422,13 @@ checksum = "3a3076410a55c90011c298b04d0cfa770b00fa04e1e3c97d3f6c9de105a03844" [[package]] name = "flate2" -version = "1.1.5" +version = "1.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bfe33edd8e85a12a67454e37f8c75e730830d83e313556ab9ebf9ee7fbeb3bfb" +checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c" dependencies = [ "crc32fast", "miniz_oxide", + "zlib-rs", ] [[package]] @@ -6944,3 +6945,9 @@ dependencies = [ "quote", "syn 2.0.110", ] + +[[package]] +name = "zlib-rs" +version = "0.6.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3be3d40e40a133f9c916ee3f9f4fa2d9d63435b5fbe1bfc6d9dae0aa0ada1513" From 3fd1107165b62823e210ec6f1060d9e463b28c22 Mon Sep 17 00:00:00 2001 From: Josh Triplett Date: Mon, 30 Mar 2026 18:57:49 -0700 Subject: [PATCH 18/20] tidy: Allow zlib-rs as a Rust dependency --- src/tools/tidy/src/deps.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/tools/tidy/src/deps.rs b/src/tools/tidy/src/deps.rs index c6624b1b3697d..b0730de771395 100644 --- a/src/tools/tidy/src/deps.rs +++ b/src/tools/tidy/src/deps.rs @@ -504,6 +504,7 @@ const PERMITTED_RUSTC_DEPENDENCIES: &[&str] = &[ "zerotrie", "zerovec", "zerovec-derive", + "zlib-rs", // tidy-alphabetical-end ]; From dd1d5b7f505f0de3585b8d8cab5959fadaa1fcb1 Mon Sep 17 00:00:00 2001 From: Josh Triplett Date: Mon, 30 Mar 2026 19:44:35 -0700 Subject: [PATCH 19/20] citool: use zlib-rs --- src/ci/citool/Cargo.lock | 19 +++++++++++++++++-- src/ci/citool/Cargo.toml | 1 + 2 files changed, 18 insertions(+), 2 deletions(-) diff --git a/src/ci/citool/Cargo.lock b/src/ci/citool/Cargo.lock index fe1c92f049e0b..a208de47256ca 100644 --- a/src/ci/citool/Cargo.lock +++ b/src/ci/citool/Cargo.lock @@ -170,6 +170,7 @@ dependencies = [ "clap", "csv", "diff", + "flate2", "glob-match", "insta", "serde", @@ -344,12 +345,13 @@ checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5" [[package]] name = "flate2" -version = "1.1.0" +version = "1.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "11faaf5a5236997af9848be0bef4db95824b1d534ebc64d0f0c6cf3e67bd38dc" +checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c" dependencies = [ "crc32fast", "miniz_oxide", + "zlib-rs", ] [[package]] @@ -630,6 +632,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3be647b768db090acb35d5ec5db2b0e1f1de11133ca123b9eacf5137868f892a" dependencies = [ "adler2", + "simd-adler32", ] [[package]] @@ -812,6 +815,12 @@ version = "1.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" +[[package]] +name = "simd-adler32" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "703d5c7ef118737c72f1af64ad2f6f8c5e1921f818cdcb97b8fe6fc69bf66214" + [[package]] name = "similar" version = "2.7.0" @@ -1187,3 +1196,9 @@ dependencies = [ "quote", "syn", ] + +[[package]] +name = "zlib-rs" +version = "0.6.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3be3d40e40a133f9c916ee3f9f4fa2d9d63435b5fbe1bfc6d9dae0aa0ada1513" diff --git a/src/ci/citool/Cargo.toml b/src/ci/citool/Cargo.toml index 0b1f2fe79bf75..f97d5e807fcc8 100644 --- a/src/ci/citool/Cargo.toml +++ b/src/ci/citool/Cargo.toml @@ -9,6 +9,7 @@ askama = "0.15.4" clap = { version = "4.5", features = ["derive"] } csv = "1" diff = "0.1" +flate2 = { version = "1.1.9", default-features = false, features = ["zlib-rs"] } # For feature flag only glob-match = "0.2" serde = { version = "1", features = ["derive"] } serde_yaml = "0.9" From 620e92f0166738113eac8ec774253501324a6e75 Mon Sep 17 00:00:00 2001 From: Peter Jaszkowiak Date: Tue, 3 Mar 2026 18:49:37 -0700 Subject: [PATCH 20/20] stabilize new Range type and iterator stabilizes `core::range::Range` stabilizes `core::range::RangeIter` stabilizes `std::range` which was missed in prior PRs Updates docs to reflect stabilization (removed "experimental") `RangeIter::remainder` is excluded from stabilization --- compiler/rustc_index/src/lib.rs | 6 +- library/core/src/range.rs | 56 ++++++++----------- library/core/src/range/iter.rs | 13 ++--- library/core/src/slice/index.rs | 4 +- library/core/src/str/traits.rs | 2 +- library/coretests/tests/lib.rs | 1 - library/std/src/lib.rs | 2 +- .../feature-gates/feature-gate-new_range.rs | 2 - .../feature-gate-new_range.stderr | 6 +- tests/ui/new-range/disabled.rs | 2 +- tests/ui/new-range/enabled.rs | 1 - tests/ui/range/new_range_stability.rs | 22 ++++++-- tests/ui/range/new_range_stability.stderr | 34 ++++------- 13 files changed, 72 insertions(+), 79 deletions(-) diff --git a/compiler/rustc_index/src/lib.rs b/compiler/rustc_index/src/lib.rs index dc7fe03dcf3c6..1b8c8e3bd2c86 100644 --- a/compiler/rustc_index/src/lib.rs +++ b/compiler/rustc_index/src/lib.rs @@ -2,9 +2,13 @@ #![cfg_attr(all(feature = "nightly", test), feature(stmt_expr_attributes))] #![cfg_attr(all(feature = "nightly", test), feature(test))] #![cfg_attr(feature = "nightly", feature(extend_one, step_trait))] -#![cfg_attr(feature = "nightly", feature(new_range_api))] // tidy-alphabetical-end +// FIXME(#125687): new_range_api recently stabilized +// Remove this when it hits stable. cfg(bootstrap) +#![allow(stable_features)] +#![cfg_attr(feature = "nightly", feature(new_range_api))] + pub mod bit_set; #[cfg(feature = "nightly")] pub mod interval; diff --git a/library/core/src/range.rs b/library/core/src/range.rs index 2007533e68e54..d4be1b67d3862 100644 --- a/library/core/src/range.rs +++ b/library/core/src/range.rs @@ -1,19 +1,18 @@ -//! # Experimental replacement range types +//! # Replacement range types //! -//! The types within this module are meant to replace the existing -//! `Range`, `RangeInclusive`, and `RangeFrom` types in a future edition. +//! The types within this module are meant to replace the legacy `Range`, +//! `RangeInclusive`, `RangeToInclusive` and `RangeFrom` types in a future edition. //! //! ``` -//! #![feature(new_range_api)] -//! use core::range::{Range, RangeFrom, RangeInclusive}; +//! use core::range::{Range, RangeFrom, RangeInclusive, RangeToInclusive}; //! //! let arr = [0, 1, 2, 3, 4]; -//! assert_eq!(arr[ .. ], [0, 1, 2, 3, 4]); -//! assert_eq!(arr[ .. 3 ], [0, 1, 2 ]); -//! assert_eq!(arr[ ..=3 ], [0, 1, 2, 3 ]); -//! assert_eq!(arr[ RangeFrom::from(1.. )], [ 1, 2, 3, 4]); -//! assert_eq!(arr[ Range::from(1..3 )], [ 1, 2 ]); -//! assert_eq!(arr[RangeInclusive::from(1..=3)], [ 1, 2, 3 ]); +//! assert_eq!(arr[ .. ], [0, 1, 2, 3, 4]); +//! assert_eq!(arr[ .. 3 ], [0, 1, 2 ]); +//! assert_eq!(arr[RangeToInclusive::from( ..=3)], [0, 1, 2, 3 ]); +//! assert_eq!(arr[ RangeFrom::from(1.. )], [ 1, 2, 3, 4]); +//! assert_eq!(arr[ Range::from(1..3 )], [ 1, 2 ]); +//! assert_eq!(arr[ RangeInclusive::from(1..=3)], [ 1, 2, 3 ]); //! ``` use crate::fmt; @@ -21,7 +20,7 @@ use crate::hash::Hash; mod iter; -#[unstable(feature = "new_range_api", issue = "125687")] +#[unstable(feature = "new_range_api_legacy", issue = "125687")] pub mod legacy; #[doc(inline)] @@ -31,7 +30,7 @@ pub use iter::RangeFromIter; #[stable(feature = "new_range_inclusive_api", since = "1.95.0")] pub use iter::RangeInclusiveIter; #[doc(inline)] -#[unstable(feature = "new_range_api", issue = "125687")] +#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")] pub use iter::RangeIter; // FIXME(#125687): re-exports temporarily removed @@ -57,7 +56,6 @@ use crate::ops::{IntoBounds, OneSidedRange, OneSidedRangeBound, RangeBounds}; /// # Examples /// /// ``` -/// #![feature(new_range_api)] /// use core::range::Range; /// /// assert_eq!(Range::from(3..5), Range { start: 3, end: 5 }); @@ -66,17 +64,17 @@ use crate::ops::{IntoBounds, OneSidedRange, OneSidedRangeBound, RangeBounds}; #[lang = "RangeCopy"] #[derive(Copy, Hash)] #[derive_const(Clone, Default, PartialEq, Eq)] -#[unstable(feature = "new_range_api", issue = "125687")] +#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")] pub struct Range { /// The lower bound of the range (inclusive). - #[unstable(feature = "new_range_api", issue = "125687")] + #[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")] pub start: Idx, /// The upper bound of the range (exclusive). - #[unstable(feature = "new_range_api", issue = "125687")] + #[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")] pub end: Idx, } -#[unstable(feature = "new_range_api", issue = "125687")] +#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")] impl fmt::Debug for Range { fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { self.start.fmt(fmt)?; @@ -94,7 +92,6 @@ impl Range { /// # Examples /// /// ``` - /// #![feature(new_range_api)] /// use core::range::Range; /// /// let mut i = Range::from(3..9).iter().map(|n| n*n); @@ -102,7 +99,7 @@ impl Range { /// assert_eq!(i.next(), Some(16)); /// assert_eq!(i.next(), Some(25)); /// ``` - #[unstable(feature = "new_range_api", issue = "125687")] + #[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")] #[inline] pub fn iter(&self) -> RangeIter { self.clone().into_iter() @@ -115,7 +112,6 @@ impl> Range { /// # Examples /// /// ``` - /// #![feature(new_range_api)] /// use core::range::Range; /// /// assert!(!Range::from(3..5).contains(&2)); @@ -132,7 +128,7 @@ impl> Range { /// assert!(!Range::from(f32::NAN..1.0).contains(&0.5)); /// ``` #[inline] - #[unstable(feature = "new_range_api", issue = "125687")] + #[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")] #[rustc_const_unstable(feature = "const_range", issue = "none")] pub const fn contains(&self, item: &U) -> bool where @@ -147,7 +143,6 @@ impl> Range { /// # Examples /// /// ``` - /// #![feature(new_range_api)] /// use core::range::Range; /// /// assert!(!Range::from(3..5).is_empty()); @@ -158,7 +153,6 @@ impl> Range { /// The range is empty if either side is incomparable: /// /// ``` - /// #![feature(new_range_api)] /// use core::range::Range; /// /// assert!(!Range::from(3.0..5.0).is_empty()); @@ -166,7 +160,7 @@ impl> Range { /// assert!( Range::from(f32::NAN..5.0).is_empty()); /// ``` #[inline] - #[unstable(feature = "new_range_api", issue = "125687")] + #[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")] #[rustc_const_unstable(feature = "const_range", issue = "none")] pub const fn is_empty(&self) -> bool where @@ -176,7 +170,7 @@ impl> Range { } } -#[unstable(feature = "new_range_api", issue = "125687")] +#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")] #[rustc_const_unstable(feature = "const_range", issue = "none")] impl const RangeBounds for Range { fn start_bound(&self) -> Bound<&T> { @@ -193,7 +187,7 @@ impl const RangeBounds for Range { /// If you need to use this implementation where `T` is unsized, /// consider using the `RangeBounds` impl for a 2-tuple of [`Bound<&T>`][Bound], /// i.e. replace `start..end` with `(Bound::Included(start), Bound::Excluded(end))`. -#[unstable(feature = "new_range_api", issue = "125687")] +#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")] #[rustc_const_unstable(feature = "const_range", issue = "none")] impl const RangeBounds for Range<&T> { fn start_bound(&self) -> Bound<&T> { @@ -204,8 +198,7 @@ impl const RangeBounds for Range<&T> { } } -// #[unstable(feature = "range_into_bounds", issue = "136903")] -#[unstable(feature = "new_range_api", issue = "125687")] +#[unstable(feature = "range_into_bounds", issue = "136903")] #[rustc_const_unstable(feature = "const_range", issue = "none")] impl const IntoBounds for Range { fn into_bounds(self) -> (Bound, Bound) { @@ -213,7 +206,7 @@ impl const IntoBounds for Range { } } -#[unstable(feature = "new_range_api", issue = "125687")] +#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")] #[rustc_const_unstable(feature = "const_convert", issue = "143773")] impl const From> for legacy::Range { #[inline] @@ -221,8 +214,7 @@ impl const From> for legacy::Range { Self { start: value.start, end: value.end } } } - -#[unstable(feature = "new_range_api", issue = "125687")] +#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")] #[rustc_const_unstable(feature = "const_convert", issue = "143773")] impl const From> for Range { #[inline] diff --git a/library/core/src/range/iter.rs b/library/core/src/range/iter.rs index c29b498bd25f8..a5db3699bc402 100644 --- a/library/core/src/range/iter.rs +++ b/library/core/src/range/iter.rs @@ -6,7 +6,7 @@ use crate::range::{Range, RangeFrom, RangeInclusive, legacy}; use crate::{intrinsics, mem}; /// By-value [`Range`] iterator. -#[unstable(feature = "new_range_api", issue = "125687")] +#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")] #[derive(Debug, Clone)] pub struct RangeIter(legacy::Range); @@ -17,7 +17,6 @@ impl RangeIter { /// # Examples /// /// ``` - /// #![feature(new_range_api)] /// #![feature(new_range_remainder)] /// /// let range = core::range::Range::from(3..11); @@ -65,7 +64,7 @@ unsafe_range_trusted_random_access_impl! { u64 i64 } -#[unstable(feature = "new_range_api", issue = "125687")] +#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")] impl Iterator for RangeIter { type Item = A; @@ -133,7 +132,7 @@ impl Iterator for RangeIter { } } -#[unstable(feature = "new_range_api", issue = "125687")] +#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")] impl DoubleEndedIterator for RangeIter { #[inline] fn next_back(&mut self) -> Option { @@ -154,10 +153,10 @@ impl DoubleEndedIterator for RangeIter { #[unstable(feature = "trusted_len", issue = "37572")] unsafe impl TrustedLen for RangeIter {} -#[unstable(feature = "new_range_api", issue = "125687")] +#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")] impl FusedIterator for RangeIter {} -#[unstable(feature = "new_range_api", issue = "125687")] +#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")] impl IntoIterator for Range { type Item = A; type IntoIter = RangeIter; @@ -300,7 +299,7 @@ impl IntoIterator for RangeInclusive { // since e.g. `(0..=u64::MAX).len()` would be `u64::MAX + 1`. macro_rules! range_exact_iter_impl { ($($t:ty)*) => ($( - #[unstable(feature = "new_range_api", issue = "125687")] + #[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")] impl ExactSizeIterator for RangeIter<$t> { } )*) } diff --git a/library/core/src/slice/index.rs b/library/core/src/slice/index.rs index b30f82a5783ad..f1727a1f629cb 100644 --- a/library/core/src/slice/index.rs +++ b/library/core/src/slice/index.rs @@ -125,7 +125,7 @@ mod private_slice_index { #[stable(feature = "slice_index_with_ops_bound_pair", since = "1.53.0")] impl Sealed for (ops::Bound, ops::Bound) {} - #[unstable(feature = "new_range_api", issue = "125687")] + #[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")] impl Sealed for range::Range {} #[stable(feature = "new_range_inclusive_api", since = "1.95.0")] impl Sealed for range::RangeInclusive {} @@ -458,7 +458,7 @@ unsafe impl const SliceIndex<[T]> for ops::Range { } } -#[unstable(feature = "new_range_api", issue = "125687")] +#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")] #[rustc_const_unstable(feature = "const_index", issue = "143775")] unsafe impl const SliceIndex<[T]> for range::Range { type Output = [T]; diff --git a/library/core/src/str/traits.rs b/library/core/src/str/traits.rs index 336f074883d25..da0039f055fde 100644 --- a/library/core/src/str/traits.rs +++ b/library/core/src/str/traits.rs @@ -258,7 +258,7 @@ unsafe impl const SliceIndex for ops::Range { } } -#[unstable(feature = "new_range_api", issue = "125687")] +#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")] #[rustc_const_unstable(feature = "const_index", issue = "143775")] unsafe impl const SliceIndex for range::Range { type Output = str; diff --git a/library/coretests/tests/lib.rs b/library/coretests/tests/lib.rs index fba144c0e9839..90a33aeead150 100644 --- a/library/coretests/tests/lib.rs +++ b/library/coretests/tests/lib.rs @@ -85,7 +85,6 @@ #![feature(maybe_uninit_uninit_array_transpose)] #![feature(min_specialization)] #![feature(never_type)] -#![feature(new_range_api)] #![feature(next_index)] #![feature(non_exhaustive_omitted_patterns_lint)] #![feature(nonzero_from_str_radix)] diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs index 7497fa100eb9e..1730742dffe93 100644 --- a/library/std/src/lib.rs +++ b/library/std/src/lib.rs @@ -537,7 +537,7 @@ pub use core::option; pub use core::pin; #[stable(feature = "rust1", since = "1.0.0")] pub use core::ptr; -#[unstable(feature = "new_range_api", issue = "125687")] +#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")] pub use core::range; #[stable(feature = "rust1", since = "1.0.0")] pub use core::result; diff --git a/tests/ui/feature-gates/feature-gate-new_range.rs b/tests/ui/feature-gates/feature-gate-new_range.rs index 32eeb0424b645..6fd4f19fa8dc6 100644 --- a/tests/ui/feature-gates/feature-gate-new_range.rs +++ b/tests/ui/feature-gates/feature-gate-new_range.rs @@ -1,5 +1,3 @@ -#![feature(new_range_api)] - fn main() { let a: core::range::RangeFrom = 1..; //~^ ERROR mismatched types diff --git a/tests/ui/feature-gates/feature-gate-new_range.stderr b/tests/ui/feature-gates/feature-gate-new_range.stderr index b7f70d30bfa0b..c7f2d2171b106 100644 --- a/tests/ui/feature-gates/feature-gate-new_range.stderr +++ b/tests/ui/feature-gates/feature-gate-new_range.stderr @@ -1,5 +1,5 @@ error[E0308]: mismatched types - --> $DIR/feature-gate-new_range.rs:4:41 + --> $DIR/feature-gate-new_range.rs:2:41 | LL | let a: core::range::RangeFrom = 1..; | -------------------------- ^^^ expected `RangeFrom`, found `RangeFrom<{integer}>` @@ -14,7 +14,7 @@ LL | let a: core::range::RangeFrom = (1..).into(); | + ++++++++ error[E0308]: mismatched types - --> $DIR/feature-gate-new_range.rs:6:37 + --> $DIR/feature-gate-new_range.rs:4:37 | LL | let b: core::range::Range = 2..3; | ---------------------- ^^^^ expected `Range`, found `Range<{integer}>` @@ -29,7 +29,7 @@ LL | let b: core::range::Range = (2..3).into(); | + ++++++++ error[E0308]: mismatched types - --> $DIR/feature-gate-new_range.rs:8:46 + --> $DIR/feature-gate-new_range.rs:6:46 | LL | let c: core::range::RangeInclusive = 4..=5; | ------------------------------- ^^^^^ expected `RangeInclusive`, found `RangeInclusive<{integer}>` diff --git a/tests/ui/new-range/disabled.rs b/tests/ui/new-range/disabled.rs index ab6fbd3276b3f..528c464117a13 100644 --- a/tests/ui/new-range/disabled.rs +++ b/tests/ui/new-range/disabled.rs @@ -1,6 +1,6 @@ //@ check-pass -#![feature(new_range_api)] +#![feature(new_range_api_legacy)] fn main() { // Unchanged diff --git a/tests/ui/new-range/enabled.rs b/tests/ui/new-range/enabled.rs index b49681eaacde3..6d9a1259b7756 100644 --- a/tests/ui/new-range/enabled.rs +++ b/tests/ui/new-range/enabled.rs @@ -1,6 +1,5 @@ //@ check-pass -#![feature(new_range_api)] #![feature(new_range)] fn main() { diff --git a/tests/ui/range/new_range_stability.rs b/tests/ui/range/new_range_stability.rs index 71a0f02e58968..965be17efa747 100644 --- a/tests/ui/range/new_range_stability.rs +++ b/tests/ui/range/new_range_stability.rs @@ -6,6 +6,7 @@ use std::range::{ RangeToInclusive, RangeFrom, RangeFromIter, + Range, }; fn range_inclusive(mut r: RangeInclusive) { @@ -43,13 +44,24 @@ fn range_from(mut r: RangeFrom) { i.remainder(); //~ ERROR unstable } -// Unstable module +fn range(mut r: Range) { + &[1, 2, 3][r]; -use std::range::legacy; //~ ERROR unstable + r.start; + r.end; + r.contains(&5); + r.is_empty(); + r.iter(); -// Unstable types + let mut i = r.into_iter(); + i.next(); -use std::range::Range; //~ ERROR unstable -use std::range::RangeIter; //~ ERROR unstable + // Left unstable + i.remainder(); //~ ERROR unstable +} + +// Unstable module + +use std::range::legacy; //~ ERROR unstable fn main() {} diff --git a/tests/ui/range/new_range_stability.stderr b/tests/ui/range/new_range_stability.stderr index 64ef6a4166873..ac269a2b2227e 100644 --- a/tests/ui/range/new_range_stability.stderr +++ b/tests/ui/range/new_range_stability.stderr @@ -1,35 +1,25 @@ -error[E0658]: use of unstable library feature `new_range_api` - --> $DIR/new_range_stability.rs:48:5 +error[E0658]: use of unstable library feature `new_range_api_legacy` + --> $DIR/new_range_stability.rs:65:5 | LL | use std::range::legacy; | ^^^^^^^^^^^^^^^^^^ | = note: see issue #125687 for more information - = help: add `#![feature(new_range_api)]` to the crate attributes to enable + = help: add `#![feature(new_range_api_legacy)]` to the crate attributes to enable = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date -error[E0658]: use of unstable library feature `new_range_api` - --> $DIR/new_range_stability.rs:52:5 - | -LL | use std::range::Range; - | ^^^^^^^^^^^^^^^^^ - | - = note: see issue #125687 for more information - = help: add `#![feature(new_range_api)]` to the crate attributes to enable - = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date - -error[E0658]: use of unstable library feature `new_range_api` - --> $DIR/new_range_stability.rs:53:5 +error[E0658]: use of unstable library feature `new_range_remainder` + --> $DIR/new_range_stability.rs:23:7 | -LL | use std::range::RangeIter; - | ^^^^^^^^^^^^^^^^^^^^^ +LL | i.remainder(); + | ^^^^^^^^^ | - = note: see issue #125687 for more information - = help: add `#![feature(new_range_api)]` to the crate attributes to enable + = note: see issue #154458 for more information + = help: add `#![feature(new_range_remainder)]` to the crate attributes to enable = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date error[E0658]: use of unstable library feature `new_range_remainder` - --> $DIR/new_range_stability.rs:22:7 + --> $DIR/new_range_stability.rs:44:7 | LL | i.remainder(); | ^^^^^^^^^ @@ -39,7 +29,7 @@ LL | i.remainder(); = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date error[E0658]: use of unstable library feature `new_range_remainder` - --> $DIR/new_range_stability.rs:43:7 + --> $DIR/new_range_stability.rs:60:7 | LL | i.remainder(); | ^^^^^^^^^ @@ -48,6 +38,6 @@ LL | i.remainder(); = help: add `#![feature(new_range_remainder)]` to the crate attributes to enable = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date -error: aborting due to 5 previous errors +error: aborting due to 4 previous errors For more information about this error, try `rustc --explain E0658`.