mathieu/os-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Auto merge of #134492 - jhpratt:rollup-elpdwd9, r=jhpratt

Browse source 
Rollup of 8 pull requests

Successful merges:

 - #132056 (Stabilize `#[diagnostic::do_not_recommend]`)
 - #133643 (-Znext-solver: modify candidate preference rules)
 - #134388 (Update books)
 - #134418 (Advent of `tests/ui` (misc cleanups and improvements) [3/N])
 - #134473 (chore: fix some typos)
 - #134481 (Point at lint name instead of whole attr for gated lints)
 - #134484 (Add nnethercote to the `triagebot.toml` vacation list.)
 - #134490 (Fix typo in ptr/mod.rs)

r? `@ghost`
`@rustbot` modify labels: rollup
This commit is contained in:
bors 2024-12-19 05:43:07 +00:00
commit bab18a542d
101 changed files with 726 additions and 401 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
compiler/rustc_codegen_cranelift/src/compiler_builtins.rs
View file

@ -3,7 +3,7 @@ use std::ffi::c_int;
#[cfg(feature = "jit")]
use std::ffi::c_void;
// FIXME replace with core::ffi::c_size_t once stablized
// FIXME replace with core::ffi::c_size_t once stabilized
#[allow(non_camel_case_types)]
#[cfg(feature = "jit")]
type size_t = usize;

2
compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
View file

@ -66,7 +66,7 @@ fn get_simple_intrinsic<'gcc, 'tcx>(
sym::log2f64 => "log2",
sym::fmaf32 => "fmaf",
sym::fmaf64 => "fma",
// FIXME: calling `fma` from libc without FMA target feature uses expensive sofware emulation
// FIXME: calling `fma` from libc without FMA target feature uses expensive software emulation
sym::fmuladdf32 => "fmaf", // TODO: use gcc intrinsic analogous to llvm.fmuladd.f32
sym::fmuladdf64 => "fma", // TODO: use gcc intrinsic analogous to llvm.fmuladd.f64
sym::fabsf32 => "fabsf",

2
compiler/rustc_errors/src/emitter.rs
View file

@ -2523,7 +2523,7 @@ impl HumanEmitter {
buffer.puts(*row_num, max_line_num_len + 1, "+ ", Style::Addition);
}
[] => {
// FIXME: needed? Doesn't get excercised in any test.
// FIXME: needed? Doesn't get exercised in any test.
self.draw_col_separator_no_space(buffer, *row_num, max_line_num_len + 1);
}
_ => {

2
compiler/rustc_errors/src/markdown/parse.rs
View file

@ -346,7 +346,7 @@ fn parse_with_end_pat<'a>(
None
}
/// Resturn `(match, residual)` to end of line. The EOL is returned with the
/// Return `(match, residual)` to end of line. The EOL is returned with the
/// residual.
fn parse_to_newline(buf: &[u8]) -> (&[u8], &[u8]) {
buf.iter().position(|ch| *ch == b'\n').map_or((buf, &[]), |pos| buf.split_at(pos))

2
compiler/rustc_feature/src/accepted.rs
View file

@ -178,6 +178,8 @@ declare_features! (
(accepted, destructuring_assignment, "1.59.0", Some(71126)),
/// Allows using the `#[diagnostic]` attribute tool namespace
(accepted, diagnostic_namespace, "1.78.0", Some(111996)),
/// Controls errors in trait implementations.
(accepted, do_not_recommend, "CURRENT_RUSTC_VERSION", Some(51992)),
/// Allows `#[doc(alias = "...")]`.
(accepted, doc_alias, "1.48.0", Some(50146)),
/// Allows `..` in tuple (struct) patterns.

5
compiler/rustc_feature/src/builtin_attrs.rs
View file

@ -1187,10 +1187,9 @@ pub static BUILTIN_ATTRIBUTE_MAP: LazyLock<FxHashMap<Symbol, &BuiltinAttribute>>
map
});
pub fn is_stable_diagnostic_attribute(sym: Symbol, features: &Features) -> bool {
pub fn is_stable_diagnostic_attribute(sym: Symbol, _features: &Features) -> bool {
match sym {
sym::on_unimplemented => true,
sym::do_not_recommend => features.do_not_recommend(),
sym::on_unimplemented | sym::do_not_recommend => true,
_ => false,
}
}

2
compiler/rustc_feature/src/unstable.rs
View file

@ -462,8 +462,6 @@ declare_features! (
(unstable, deprecated_suggestion, "1.61.0", Some(94785)),
/// Allows deref patterns.
(incomplete, deref_patterns, "1.79.0", Some(87121)),
/// Controls errors in trait implementations.
(unstable, do_not_recommend, "1.67.0", Some(51992)),
/// Tells rustdoc to automatically generate `#[doc(cfg(...))]`.
(unstable, doc_auto_cfg, "1.58.0", Some(43781)),
/// Allows `#[doc(cfg(...))]`.

2
compiler/rustc_lint/src/levels.rs
View file

@ -914,7 +914,7 @@ impl<'s, P: LintLevelsProvider> LintLevelsBuilder<'s, P> {
let src = LintLevelSource::Node { name, span: sp, reason };
for &id in ids {
if self.check_gated_lint(id, attr.span(), false) {
if self.check_gated_lint(id, sp, false) {
self.insert_spec(id, (level, src));
}
}

2
compiler/rustc_middle/src/ty/mod.rs
View file

@ -971,7 +971,7 @@ pub struct ParamEnv<'tcx> {
}
impl<'tcx> rustc_type_ir::inherent::ParamEnv<TyCtxt<'tcx>> for ParamEnv<'tcx> {
fn caller_bounds(self) -> impl IntoIterator<Item = ty::Clause<'tcx>> {
fn caller_bounds(self) -> impl inherent::SliceLike<Item = ty::Clause<'tcx>> {
self.caller_bounds()
}
}

119
compiler/rustc_next_trait_solver/src/canonicalizer.rs
View file

@ -3,6 +3,7 @@ use std::cmp::Ordering;
use rustc_type_ir::data_structures::HashMap;
use rustc_type_ir::fold::{TypeFoldable, TypeFolder, TypeSuperFoldable};
use rustc_type_ir::inherent::*;
use rustc_type_ir::solve::{Goal, QueryInput};
use rustc_type_ir::visit::TypeVisitableExt;
use rustc_type_ir::{
self as ty, Canonical, CanonicalTyVarKind, CanonicalVarInfo, CanonicalVarKind, InferCtxtLike,
@ -17,8 +18,11 @@ use crate::delegate::SolverDelegate;
/// while canonicalizing the response happens in the context of the
/// query.
#[derive(Debug, Clone, Copy)]
pub enum CanonicalizeMode {
Input,
enum CanonicalizeMode {
/// When canonicalizing the `param_env`, we keep `'static` as merging
/// trait candidates relies on it when deciding whether a where-bound
/// is trivial.
Input { keep_static: bool },
/// FIXME: We currently return region constraints referring to
/// placeholders and inference variables from a binder instantiated
/// inside of the query.
@ -59,15 +63,15 @@ pub struct Canonicalizer<'a, D: SolverDelegate<Interner = I>, I: Interner> {
}
impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
pub fn canonicalize<T: TypeFoldable<I>>(
pub fn canonicalize_response<T: TypeFoldable<I>>(
delegate: &'a D,
canonicalize_mode: CanonicalizeMode,
max_input_universe: ty::UniverseIndex,
variables: &'a mut Vec<I::GenericArg>,
value: T,
) -> ty::Canonical<I, T> {
let mut canonicalizer = Canonicalizer {
delegate,
canonicalize_mode,
canonicalize_mode: CanonicalizeMode::Response { max_input_universe },
variables,
variable_lookup_table: Default::default(),
@ -80,9 +84,67 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
let value = value.fold_with(&mut canonicalizer);
assert!(!value.has_infer(), "unexpected infer in {value:?}");
assert!(!value.has_placeholders(), "unexpected placeholders in {value:?}");
let (max_universe, variables) = canonicalizer.finalize();
Canonical { max_universe, variables, value }
}
/// When canonicalizing query inputs, we keep `'static` in the `param_env`
/// but erase it everywhere else. We generally don't want to depend on region
/// identity, so while it should not matter whether `'static` is kept in the
/// value or opaque type storage as well, this prevents us from accidentally
/// relying on it in the future.
///
/// We want to keep the option of canonicalizing `'static` to an existential
/// variable in the future by changing the way we detect global where-bounds.
pub fn canonicalize_input<P: TypeFoldable<I>>(
delegate: &'a D,
variables: &'a mut Vec<I::GenericArg>,
input: QueryInput<I, P>,
) -> ty::Canonical<I, QueryInput<I, P>> {
// First canonicalize the `param_env` while keeping `'static`
let mut env_canonicalizer = Canonicalizer {
delegate,
canonicalize_mode: CanonicalizeMode::Input { keep_static: true },
variables,
variable_lookup_table: Default::default(),
primitive_var_infos: Vec::new(),
binder_index: ty::INNERMOST,
cache: Default::default(),
};
let param_env = input.goal.param_env.fold_with(&mut env_canonicalizer);
debug_assert_eq!(env_canonicalizer.binder_index, ty::INNERMOST);
// Then canonicalize the rest of the input without keeping `'static`
// while *mostly* reusing the canonicalizer from above.
let mut rest_canonicalizer = Canonicalizer {
delegate,
canonicalize_mode: CanonicalizeMode::Input { keep_static: false },
variables: env_canonicalizer.variables,
// We're able to reuse the `variable_lookup_table` as whether or not
// it already contains an entry for `'static` does not matter.
variable_lookup_table: env_canonicalizer.variable_lookup_table,
primitive_var_infos: env_canonicalizer.primitive_var_infos,
binder_index: ty::INNERMOST,
// We do not reuse the cache as it may contain entries whose canonicalized
// value contains `'static`. While we could alternatively handle this by
// checking for `'static` when using cached entries, this does not
// feel worth the effort. I do not expect that a `ParamEnv` will ever
// contain large enough types for caching to be necessary.
cache: Default::default(),
};
let predicate = input.goal.predicate.fold_with(&mut rest_canonicalizer);
let goal = Goal { param_env, predicate };
let predefined_opaques_in_body =
input.predefined_opaques_in_body.fold_with(&mut rest_canonicalizer);
let value = QueryInput { goal, predefined_opaques_in_body };
assert!(!value.has_infer(), "unexpected infer in {value:?}");
assert!(!value.has_placeholders(), "unexpected placeholders in {value:?}");
let (max_universe, variables) = rest_canonicalizer.finalize();
Canonical { max_universe, variables, value }
}
@ -126,7 +188,7 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
// all information which should not matter for the solver.
//
// For this we compress universes as much as possible.
CanonicalizeMode::Input => {}
CanonicalizeMode::Input { .. } => {}
// When canonicalizing a response we map a universes already entered
// by the caller to the root universe and only return useful universe
// information for placeholders and inference variables created inside
@ -290,17 +352,15 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
}
},
ty::Placeholder(placeholder) => match self.canonicalize_mode {
CanonicalizeMode::Input => CanonicalVarKind::PlaceholderTy(PlaceholderLike::new(
placeholder.universe(),
self.variables.len().into(),
)),
CanonicalizeMode::Input { .. } => CanonicalVarKind::PlaceholderTy(
PlaceholderLike::new(placeholder.universe(), self.variables.len().into()),
),
CanonicalizeMode::Response { .. } => CanonicalVarKind::PlaceholderTy(placeholder),
},
ty::Param(_) => match self.canonicalize_mode {
CanonicalizeMode::Input => CanonicalVarKind::PlaceholderTy(PlaceholderLike::new(
ty::UniverseIndex::ROOT,
self.variables.len().into(),
)),
CanonicalizeMode::Input { .. } => CanonicalVarKind::PlaceholderTy(
PlaceholderLike::new(ty::UniverseIndex::ROOT, self.variables.len().into()),
),
CanonicalizeMode::Response { .. } => panic!("param ty in response: {t:?}"),
},
ty::Bool
@ -357,21 +417,30 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I> for Canonicaliz
let kind = match r.kind() {
ty::ReBound(..) => return r,
// We may encounter `ReStatic` in item signatures or the hidden type
// of an opaque. `ReErased` should only be encountered in the hidden
// We don't canonicalize `ReStatic` in the `param_env` as we use it
// when checking whether a `ParamEnv` candidate is global.
ty::ReStatic => match self.canonicalize_mode {
CanonicalizeMode::Input { keep_static: false } => {
CanonicalVarKind::Region(ty::UniverseIndex::ROOT)
}
CanonicalizeMode::Input { keep_static: true }
| CanonicalizeMode::Response { .. } => return r,
},
// `ReErased` should only be encountered in the hidden
// type of an opaque for regions that are ignored for the purposes of
// captures.
//
// FIXME: We should investigate the perf implications of not uniquifying
// `ReErased`. We may be able to short-circuit registering region
// obligations if we encounter a `ReErased` on one side, for example.
ty::ReStatic | ty::ReErased | ty::ReError(_) => match self.canonicalize_mode {
CanonicalizeMode::Input => CanonicalVarKind::Region(ty::UniverseIndex::ROOT),
ty::ReErased | ty::ReError(_) => match self.canonicalize_mode {
CanonicalizeMode::Input { .. } => CanonicalVarKind::Region(ty::UniverseIndex::ROOT),
CanonicalizeMode::Response { .. } => return r,
},
ty::ReEarlyParam(_) | ty::ReLateParam(_) => match self.canonicalize_mode {
CanonicalizeMode::Input => CanonicalVarKind::Region(ty::UniverseIndex::ROOT),
CanonicalizeMode::Input { .. } => CanonicalVarKind::Region(ty::UniverseIndex::ROOT),
CanonicalizeMode::Response { .. } => {
panic!("unexpected region in response: {r:?}")
}
@ -379,7 +448,7 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I> for Canonicaliz
ty::RePlaceholder(placeholder) => match self.canonicalize_mode {
// We canonicalize placeholder regions as existentials in query inputs.
CanonicalizeMode::Input => CanonicalVarKind::Region(ty::UniverseIndex::ROOT),
CanonicalizeMode::Input { .. } => CanonicalVarKind::Region(ty::UniverseIndex::ROOT),
CanonicalizeMode::Response { max_input_universe } => {
// If we have a placeholder region inside of a query, it must be from
// a new universe.
@ -397,7 +466,9 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I> for Canonicaliz
"region vid should have been resolved fully before canonicalization"
);
match self.canonicalize_mode {
CanonicalizeMode::Input => CanonicalVarKind::Region(ty::UniverseIndex::ROOT),
CanonicalizeMode::Input { keep_static: _ } => {
CanonicalVarKind::Region(ty::UniverseIndex::ROOT)
}
CanonicalizeMode::Response { .. } => {
CanonicalVarKind::Region(self.delegate.universe_of_lt(vid).unwrap())
}
@ -434,7 +505,7 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I> for Canonicaliz
ty::InferConst::Fresh(_) => todo!(),
},
ty::ConstKind::Placeholder(placeholder) => match self.canonicalize_mode {
CanonicalizeMode::Input => CanonicalVarKind::PlaceholderConst(
CanonicalizeMode::Input { .. } => CanonicalVarKind::PlaceholderConst(
PlaceholderLike::new(placeholder.universe(), self.variables.len().into()),
),
CanonicalizeMode::Response { .. } => {
@ -442,7 +513,7 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I> for Canonicaliz
}
},
ty::ConstKind::Param(_) => match self.canonicalize_mode {
CanonicalizeMode::Input => CanonicalVarKind::PlaceholderConst(
CanonicalizeMode::Input { .. } => CanonicalVarKind::PlaceholderConst(
PlaceholderLike::new(ty::UniverseIndex::ROOT, self.variables.len().into()),
),
CanonicalizeMode::Response { .. } => panic!("param ty in response: {c:?}"),

134
compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
View file

@ -11,6 +11,7 @@ use rustc_type_ir::visit::TypeVisitableExt as _;
use rustc_type_ir::{self as ty, Interner, TypingMode, Upcast as _, elaborate};
use tracing::{debug, instrument};
use super::trait_goals::TraitGoalProvenVia;
use crate::delegate::SolverDelegate;
use crate::solve::inspect::ProbeKind;
use crate::solve::{
@ -337,15 +338,6 @@ where
self.assemble_param_env_candidates(goal, &mut candidates);
match self.typing_mode() {
TypingMode::Coherence => {}
TypingMode::Analysis { .. }
| TypingMode::PostBorrowckAnalysis { .. }
| TypingMode::PostAnalysis => {
self.discard_impls_shadowed_by_env(goal, &mut candidates);
}
}
candidates
}
@ -500,7 +492,7 @@ where
goal: Goal<I, G>,
candidates: &mut Vec<Candidate<I>>,
) {
for (i, assumption) in goal.param_env.caller_bounds().into_iter().enumerate() {
for (i, assumption) in goal.param_env.caller_bounds().iter().enumerate() {
candidates.extend(G::probe_and_consider_implied_clause(
self,
CandidateSource::ParamEnv(i),
@ -733,72 +725,64 @@ where
})
}
/// If there's a where-bound for the current goal, do not use any impl candidates
/// to prove the current goal. Most importantly, if there is a where-bound which does
/// not specify any associated types, we do not allow normalizing the associated type
/// by using an impl, even if it would apply.
/// We sadly can't simply take all possible candidates for normalization goals
/// and check whether they result in the same constraints. We want to make sure
/// that trying to normalize an alias doesn't result in constraints which aren't
/// otherwise required.
///
/// <https://github.com/rust-lang/trait-system-refactor-initiative/issues/76>
// FIXME(@lcnr): The current structure here makes me unhappy and feels ugly. idk how
// to improve this however. However, this should make it fairly straightforward to refine
// the filtering going forward, so it seems alright-ish for now.
#[instrument(level = "debug", skip(self, goal))]
fn discard_impls_shadowed_by_env<G: GoalKind<D>>(
&mut self,
goal: Goal<I, G>,
candidates: &mut Vec<Candidate<I>>,
) {
let cx = self.cx();
let trait_goal: Goal<I, ty::TraitPredicate<I>> =
goal.with(cx, goal.predicate.trait_ref(cx));
let mut trait_candidates_from_env = vec![];
self.probe(|_| ProbeKind::ShadowedEnvProbing).enter(|ecx| {
ecx.assemble_param_env_candidates(trait_goal, &mut trait_candidates_from_env);
ecx.assemble_alias_bound_candidates(trait_goal, &mut trait_candidates_from_env);
});
if !trait_candidates_from_env.is_empty() {
let trait_env_result = self.merge_candidates(trait_candidates_from_env);
match trait_env_result.unwrap().value.certainty {
// If proving the trait goal succeeds by using the env,
// we freely drop all impl candidates.
//
// FIXME(@lcnr): It feels like this could easily hide
// a forced ambiguity candidate added earlier.
// This feels dangerous.
Certainty::Yes => {
candidates.retain(|c| match c.source {
CandidateSource::Impl(_) | CandidateSource::BuiltinImpl(_) => {
debug!(?c, "discard impl candidate");
false
}
CandidateSource::ParamEnv(_) | CandidateSource::AliasBound => true,
CandidateSource::CoherenceUnknowable => panic!("uh oh"),
});
}
// If it is still ambiguous we instead just force the whole goal
// to be ambig and wait for inference constraints. See
// tests/ui/traits/next-solver/env-shadows-impls/ambig-env-no-shadow.rs
Certainty::Maybe(cause) => {
debug!(?cause, "force ambiguity");
*candidates = self.forced_ambiguity(cause).into_iter().collect();
}
}
}
}
/// If there are multiple ways to prove a trait or projection goal, we have
/// to somehow try to merge the candidates into one. If that fails, we return
/// ambiguity.
/// Most notably, when proving a trait goal by via a where-bound, we should not
/// normalize via impls which have stricter region constraints than the where-bound:
///
/// ```rust
/// trait Trait<'a> {
/// type Assoc;
/// }
///
/// impl<'a, T: 'a> Trait<'a> for T {
/// type Assoc = u32;
/// }
///
/// fn with_bound<'a, T: Trait<'a>>(_value: T::Assoc) {}
/// ```
///
/// The where-bound of `with_bound` doesn't specify the associated type, so we would
/// only be able to normalize `<T as Trait<'a>>::Assoc` by using the impl. This impl
/// adds a `T: 'a` bound however, which would result in a region error. Given that the
/// user explicitly wrote that `T: Trait<'a>` holds, this is undesirable and we instead
/// treat the alias as rigid.
///
/// See trait-system-refactor-initiative#124 for more details.
#[instrument(level = "debug", skip(self), ret)]
pub(super) fn merge_candidates(&mut self, candidates: Vec<Candidate<I>>) -> QueryResult<I> {
// First try merging all candidates. This is complete and fully sound.
let responses = candidates.iter().map(|c| c.result).collect::<Vec<_>>();
if let Some(result) = self.try_merge_responses(&responses) {
return Ok(result);
} else {
self.flounder(&responses)
}
pub(super) fn merge_candidates(
&mut self,
proven_via: Option<TraitGoalProvenVia>,
candidates: Vec<Candidate<I>>,
) -> QueryResult<I> {
let Some(proven_via) = proven_via else {
// We don't care about overflow. If proving the trait goal overflowed, then
// it's enough to report an overflow error for that, we don't also have to
// overflow during normalization.
return Ok(self.make_ambiguous_response_no_constraints(MaybeCause::Ambiguity));
};
let responses: Vec<_> = match proven_via {
// Even when a trait bound has been proven using a where-bound, we
// still need to consider alias-bounds for normalization, see
// tests/ui/next-solver/alias-bound-shadowed-by-env.rs.
//
// FIXME(const_trait_impl): should this behavior also be used by
// constness checking. Doing so is *at least theoretically* breaking,
// see github.com/rust-lang/rust/issues/133044#issuecomment-2500709754
TraitGoalProvenVia::ParamEnv | TraitGoalProvenVia::AliasBound => candidates
.iter()
.filter(|c| {
matches!(c.source, CandidateSource::AliasBound | CandidateSource::ParamEnv(_))
})
.map(|c| c.result)
.collect(),
TraitGoalProvenVia::Misc => candidates.iter().map(|c| c.result).collect(),
};
self.try_merge_responses(&responses).map_or_else(|| self.flounder(&responses), Ok)
}
}

8
compiler/rustc_next_trait_solver/src/solve/effect_goals.rs
View file

@ -4,6 +4,7 @@
use rustc_type_ir::fast_reject::DeepRejectCtxt;
use rustc_type_ir::inherent::*;
use rustc_type_ir::lang_items::TraitSolverLangItem;
use rustc_type_ir::solve::inspect::ProbeKind;
use rustc_type_ir::{self as ty, Interner, elaborate};
use tracing::instrument;
@ -391,6 +392,11 @@ where
goal: Goal<I, ty::HostEffectPredicate<I>>,
) -> QueryResult<I> {
let candidates = self.assemble_and_evaluate_candidates(goal);
self.merge_candidates(candidates)
let (_, proven_via) = self.probe(|_| ProbeKind::ShadowedEnvProbing).enter(|ecx| {
let trait_goal: Goal<I, ty::TraitPredicate<I>> =
goal.with(ecx.cx(), goal.predicate.trait_ref);
ecx.compute_trait_goal(trait_goal)
})?;
self.merge_candidates(proven_via, candidates)
}
}

23
compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs
View file

@ -18,7 +18,7 @@ use rustc_type_ir::relate::solver_relating::RelateExt;
use rustc_type_ir::{self as ty, Canonical, CanonicalVarValues, InferCtxtLike, Interner};
use tracing::{debug, instrument, trace};
use crate::canonicalizer::{CanonicalizeMode, Canonicalizer};
use crate::canonicalizer::Canonicalizer;
use crate::delegate::SolverDelegate;
use crate::resolve::EagerResolver;
use crate::solve::eval_ctxt::NestedGoals;
@ -60,17 +60,13 @@ where
(goal, opaque_types).fold_with(&mut EagerResolver::new(self.delegate));
let mut orig_values = Default::default();
let canonical = Canonicalizer::canonicalize(
self.delegate,
CanonicalizeMode::Input,
&mut orig_values,
QueryInput {
let canonical =
Canonicalizer::canonicalize_input(self.delegate, &mut orig_values, QueryInput {
goal,
predefined_opaques_in_body: self
.cx()
.mk_predefined_opaques_in_body(PredefinedOpaquesData { opaque_types }),
},
);
});
let query_input = ty::CanonicalQueryInput { canonical, typing_mode: self.typing_mode() };
(orig_values, query_input)
}
@ -148,9 +144,9 @@ where
.region_constraints
.retain(|outlives| outlives.0.as_region().map_or(true, |re| re != outlives.1));
let canonical = Canonicalizer::canonicalize(
let canonical = Canonicalizer::canonicalize_response(
self.delegate,
CanonicalizeMode::Response { max_input_universe: self.max_input_universe },
self.max_input_universe,
&mut Default::default(),
Response {
var_values,
@ -428,12 +424,7 @@ where
let var_values = CanonicalVarValues { var_values: delegate.cx().mk_args(var_values) };
let state = inspect::State { var_values, data };
let state = state.fold_with(&mut EagerResolver::new(delegate));
Canonicalizer::canonicalize(
delegate,
CanonicalizeMode::Response { max_input_universe },
&mut vec![],
state,
)
Canonicalizer::canonicalize_response(delegate, max_input_universe, &mut vec![], state)
}
// FIXME: needs to be pub to be accessed by downstream

2
compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
View file

@ -440,7 +440,7 @@ where
if let Some(kind) = kind.no_bound_vars() {
match kind {
ty::PredicateKind::Clause(ty::ClauseKind::Trait(predicate)) => {
self.compute_trait_goal(Goal { param_env, predicate })
self.compute_trait_goal(Goal { param_env, predicate }).map(|(r, _via)| r)
}
ty::PredicateKind::Clause(ty::ClauseKind::HostEffect(predicate)) => {
self.compute_host_effect_goal(Goal { param_env, predicate })

25
compiler/rustc_next_trait_solver/src/solve/mod.rs
View file

@ -243,22 +243,27 @@ where
.copied()
}
fn bail_with_ambiguity(&mut self, responses: &[CanonicalResponse<I>]) -> CanonicalResponse<I> {
debug_assert!(!responses.is_empty());
if let Certainty::Maybe(maybe_cause) =
responses.iter().fold(Certainty::AMBIGUOUS, |certainty, response| {
certainty.unify_with(response.value.certainty)
})
{
self.make_ambiguous_response_no_constraints(maybe_cause)
} else {
panic!("expected flounder response to be ambiguous")
}
}
/// If we fail to merge responses we flounder and return overflow or ambiguity.
#[instrument(level = "trace", skip(self), ret)]
fn flounder(&mut self, responses: &[CanonicalResponse<I>]) -> QueryResult<I> {
if responses.is_empty() {
return Err(NoSolution);
} else {
Ok(self.bail_with_ambiguity(responses))
}
let Certainty::Maybe(maybe_cause) =
responses.iter().fold(Certainty::AMBIGUOUS, |certainty, response| {
certainty.unify_with(response.value.certainty)
})
else {
panic!("expected flounder response to be ambiguous")
};
Ok(self.make_ambiguous_response_no_constraints(maybe_cause))
}
/// Normalize a type for when it is structurally matched on.

11
compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs
View file

@ -88,10 +88,17 @@ where
/// returns `NoSolution`.
#[instrument(level = "trace", skip(self), ret)]
fn normalize_at_least_one_step(&mut self, goal: Goal<I, NormalizesTo<I>>) -> QueryResult<I> {
match goal.predicate.alias.kind(self.cx()) {
let cx = self.cx();
match goal.predicate.alias.kind(cx) {
ty::AliasTermKind::ProjectionTy | ty::AliasTermKind::ProjectionConst => {
let candidates = self.assemble_and_evaluate_candidates(goal);
self.merge_candidates(candidates)
let (_, proven_via) =
self.probe(|_| ProbeKind::ShadowedEnvProbing).enter(|ecx| {
let trait_goal: Goal<I, ty::TraitPredicate<I>> =
goal.with(cx, goal.predicate.alias.trait_ref(cx));
ecx.compute_trait_goal(trait_goal)
})?;
self.merge_candidates(proven_via, candidates)
}
ty::AliasTermKind::InherentTy => self.normalize_inherent_associated_type(goal),
ty::AliasTermKind::OpaqueTy => self.normalize_opaque_type(goal),

93
compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
View file

@ -5,6 +5,7 @@ use rustc_type_ir::data_structures::IndexSet;
use rustc_type_ir::fast_reject::DeepRejectCtxt;
use rustc_type_ir::inherent::*;
use rustc_type_ir::lang_items::TraitSolverLangItem;
use rustc_type_ir::solve::CanonicalResponse;
use rustc_type_ir::visit::TypeVisitableExt as _;
use rustc_type_ir::{self as ty, Interner, TraitPredicate, TypingMode, Upcast as _, elaborate};
use tracing::{instrument, trace};
@ -1147,13 +1148,101 @@ where
ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
})
}
}
/// How we've proven this trait goal.
///
/// This is used by `NormalizesTo` goals to only normalize
/// by using the same 'kind of candidate' we've used to prove
/// its corresponding trait goal. Most notably, we do not
/// normalize by using an impl if the trait goal has been
/// proven via a `ParamEnv` candidate.
///
/// This is necessary to avoid unnecessary region constraints,
/// see trait-system-refactor-initiative#125 for more details.
#[derive(Debug, Clone, Copy)]
pub(super) enum TraitGoalProvenVia {
/// We've proven the trait goal by something which is
/// is not a non-global where-bound or an alias-bound.
///
/// This means we don't disable any candidates during
/// normalization.
Misc,
ParamEnv,
AliasBound,
}
impl<D, I> EvalCtxt<'_, D>
where
D: SolverDelegate<Interner = I>,
I: Interner,
{
pub(super) fn merge_trait_candidates(
&mut self,
goal: Goal<I, TraitPredicate<I>>,
candidates: Vec<Candidate<I>>,
) -> Result<(CanonicalResponse<I>, Option<TraitGoalProvenVia>), NoSolution> {
if let TypingMode::Coherence = self.typing_mode() {
let all_candidates: Vec<_> = candidates.into_iter().map(|c| c.result).collect();
return if let Some(response) = self.try_merge_responses(&all_candidates) {
Ok((response, Some(TraitGoalProvenVia::Misc)))
} else {
self.flounder(&all_candidates).map(|r| (r, None))
};
}
// FIXME: prefer trivial builtin impls
// If there are non-global where-bounds, prefer where-bounds
// (including global ones) over everything else.
let has_non_global_where_bounds = candidates.iter().any(|c| match c.source {
CandidateSource::ParamEnv(idx) => {
let where_bound = goal.param_env.caller_bounds().get(idx);
where_bound.has_bound_vars() || !where_bound.is_global()
}
_ => false,
});
if has_non_global_where_bounds {
let where_bounds: Vec<_> = candidates
.iter()
.filter(|c| matches!(c.source, CandidateSource::ParamEnv(_)))
.map(|c| c.result)
.collect();
return if let Some(response) = self.try_merge_responses(&where_bounds) {
Ok((response, Some(TraitGoalProvenVia::ParamEnv)))
} else {
Ok((self.bail_with_ambiguity(&where_bounds), None))
};
}
if candidates.iter().any(|c| matches!(c.source, CandidateSource::AliasBound)) {
let alias_bounds: Vec<_> = candidates
.iter()
.filter(|c| matches!(c.source, CandidateSource::AliasBound))
.map(|c| c.result)
.collect();
return if let Some(response) = self.try_merge_responses(&alias_bounds) {
Ok((response, Some(TraitGoalProvenVia::AliasBound)))
} else {
Ok((self.bail_with_ambiguity(&alias_bounds), None))
};
}
let all_candidates: Vec<_> = candidates.into_iter().map(|c| c.result).collect();
if let Some(response) = self.try_merge_responses(&all_candidates) {
Ok((response, Some(TraitGoalProvenVia::Misc)))
} else {
self.flounder(&all_candidates).map(|r| (r, None))
}
}
#[instrument(level = "trace", skip(self))]
pub(super) fn compute_trait_goal(
&mut self,
goal: Goal<I, TraitPredicate<I>>,
) -> QueryResult<I> {
) -> Result<(CanonicalResponse<I>, Option<TraitGoalProvenVia>), NoSolution> {
let candidates = self.assemble_and_evaluate_candidates(goal);
self.merge_candidates(candidates)
self.merge_trait_candidates(goal, candidates)
}
}

3
compiler/rustc_passes/messages.ftl
View file

@ -357,6 +357,9 @@ passes_ignored_derived_impls =
passes_implied_feature_not_exist =
feature `{$implied_by}` implying `{$feature}` does not exist
passes_incorrect_do_not_recommend_args =
`#[diagnostic::do_not_recommend]` does not expect any arguments
passes_incorrect_do_not_recommend_location =
`#[diagnostic::do_not_recommend]` can only be placed on trait implementations

27
compiler/rustc_passes/src/check_attr.rs
View file

@ -115,7 +115,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
for attr in attrs {
match attr.path().as_slice() {
[sym::diagnostic, sym::do_not_recommend, ..] => {
self.check_do_not_recommend(attr.span, hir_id, target)
self.check_do_not_recommend(attr.span, hir_id, target, attr, item)
}
[sym::diagnostic, sym::on_unimplemented, ..] => {
self.check_diagnostic_on_unimplemented(attr.span, hir_id, target)
@ -348,8 +348,21 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
}
/// Checks if `#[diagnostic::do_not_recommend]` is applied on a trait impl.
fn check_do_not_recommend(&self, attr_span: Span, hir_id: HirId, target: Target) {
if !matches!(target, Target::Impl) {
fn check_do_not_recommend(
&self,
attr_span: Span,
hir_id: HirId,
target: Target,
attr: &Attribute,
item: Option<ItemLike<'_>>,
) {
if !matches!(target, Target::Impl)
|| matches!(
item,
Some(ItemLike::Item(hir::Item { kind: hir::ItemKind::Impl(_impl),.. }))
if _impl.of_trait.is_none()
)
{
self.tcx.emit_node_span_lint(
UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
hir_id,
@ -357,6 +370,14 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
errors::IncorrectDoNotRecommendLocation,
);
}
if !attr.is_word() {
self.tcx.emit_node_span_lint(
UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
hir_id,
attr_span,
errors::DoNotRecommendDoesNotExpectArgs,
);
}
}
/// Checks if `#[diagnostic::on_unimplemented]` is applied to a trait definition

4
compiler/rustc_passes/src/errors.rs
View file

@ -20,6 +20,10 @@ use crate::lang_items::Duplicate;
#[diag(passes_incorrect_do_not_recommend_location)]
pub(crate) struct IncorrectDoNotRecommendLocation;
#[derive(LintDiagnostic)]
#[diag(passes_incorrect_do_not_recommend_args)]
pub(crate) struct DoNotRecommendDoesNotExpectArgs;
#[derive(Diagnostic)]
#[diag(passes_autodiff_attr)]
pub(crate) struct AutoDiffAttr {

2
compiler/rustc_resolve/src/late.rs
View file

@ -4325,7 +4325,7 @@ impl<'a, 'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
#[inline]
/// If we're actually rustdoc then avoid giving a name resolution error for `cfg()` items or
// an invalid `use foo::*;` was found, which can cause unbounded ammounts of "item not found"
// an invalid `use foo::*;` was found, which can cause unbounded amounts of "item not found"
// errors. We silence them all.
fn should_report_errs(&self) -> bool {
!(self.r.tcx.sess.opts.actually_rustdoc && self.in_func_body)

3
compiler/rustc_resolve/src/macros.rs
View file

@ -689,8 +689,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
&& let [namespace, attribute, ..] = &*path.segments
&& namespace.ident.name == sym::diagnostic
&& !(attribute.ident.name == sym::on_unimplemented
|| (attribute.ident.name == sym::do_not_recommend
&& self.tcx.features().do_not_recommend()))
|| attribute.ident.name == sym::do_not_recommend)
{
let distance =
edit_distance(attribute.ident.name.as_str(), sym::on_unimplemented.as_str(), 5);

2
compiler/rustc_trait_selection/src/traits/mod.rs
View file

@ -599,7 +599,7 @@ pub fn try_evaluate_const<'tcx>(
// even though it is not something we should ever actually encounter.
//
// Array repeat expr counts are allowed to syntactically use generic parameters
// but must not actually depend on them in order to evalaute succesfully. This means
// but must not actually depend on them in order to evalaute successfully. This means
// that it is actually fine to evalaute them in their own environment rather than with
// the actually provided generic arguments.
tcx.dcx().delayed_bug(

2
compiler/rustc_type_ir/src/inherent.rs
View file

@ -543,7 +543,7 @@ pub trait AdtDef<I: Interner>: Copy + Debug + Hash + Eq {
}
pub trait ParamEnv<I: Interner>: Copy + Debug + Hash + Eq + TypeFoldable<I> {
fn caller_bounds(self) -> impl IntoIterator<Item = I::Clause>;
fn caller_bounds(self) -> impl SliceLike<Item = I::Clause>;
}
pub trait Features<I: Interner>: Copy {

2
library/core/src/lib.rs
View file

@ -108,12 +108,12 @@
// Library features:
// tidy-alphabetical-start
#![cfg_attr(bootstrap, feature(coverage_attribute))]
#![cfg_attr(bootstrap, feature(do_not_recommend))]
#![feature(array_ptr_get)]
#![feature(asm_experimental_arch)]
#![feature(const_eval_select)]
#![feature(const_typed_swap)]
#![feature(core_intrinsics)]
#![feature(do_not_recommend)]
#![feature(internal_impls_macro)]
#![feature(ip)]
#![feature(is_ascii_octdigit)]

2
library/core/src/ptr/mod.rs
View file

@ -84,7 +84,7 @@
// ^ we use this term instead of saying that the produced reference must
// be valid, as the validity of a reference is easily confused for the
// validity of the thing it refers to, and while the two concepts are
// closly related, they are not identical.
// closely related, they are not identical.
//!
//! These rules apply even if the result is unused!
//! (The part about being initialized is not yet fully decided, but until

2
src/doc/book

@ -1 +1 @@
Subproject commit 9900d976bbfecf4e8124da54351a9ad85ee3c7f3
Subproject commit ad2011d3bcad9f152d034faf7635c22506839d58

2
src/doc/edition-guide

@ -1 +1 @@
Subproject commit 128669297c8a7fdf771042eaec18b8adfaeaf0cd
Subproject commit bc4ce51e1d4dacb9350a92e95f6159a42de2f8c6

2
src/doc/nomicon

@ -1 +1 @@
Subproject commit 0674321898cd454764ab69702819d39a919afd68
Subproject commit 97e84a38c94bf9362b11284c20b2cb4adaa1e868

2
src/doc/reference

@ -1 +1 @@
Subproject commit ede56d1bbe132bac476b5029cd6d7508ca9572e9
Subproject commit 9f41bc11342d46544ae0732caf14ec0bcaf27376

2
src/doc/rust-by-example

@ -1 +1 @@
Subproject commit e1d1f2cdcee4d52b9a01ff7c448be4372a377b70
Subproject commit 76406337f4131253443aea0ed7e7f451b464117c

2
src/doc/rustc-dev-guide

@ -1 +1 @@
Subproject commit b21d99b770f9aceb0810c843847c52f86f45d2ed
Subproject commit 7f7ba48f04abc2ad25e52f30b5e2bffa286b019f

33
tests/crashes/133639.rs
View file

@ -1,33 +0,0 @@
//@ known-bug: #133639
#![feature(with_negative_coherence)]
#![feature(min_specialization)]
#![feature(generic_const_exprs)]
#![crate_type = "lib"]
use std::str::FromStr;
struct a<const b: bool>;
trait c {}
impl<const d: u32> FromStr for e<d>
where
a<{ d <= 2 }>: c,
{
type Err = ();
fn from_str(f: &str) -> Result<Self, Self::Err> {
unimplemented!()
}
}
struct e<const d: u32>;
impl<const d: u32> FromStr for e<d>
where
a<{ d <= 2 }>: c,
{
type Err = ();
fn from_str(f: &str) -> Result<Self, Self::Err> {
unimplemented!()
}
}

4
tests/rustdoc-ui/lints/feature-gate-rustdoc_missing_doc_code_examples.stderr
View file

@ -1,8 +1,8 @@
error: unknown lint: `rustdoc::missing_doc_code_examples`
--> $DIR/feature-gate-rustdoc_missing_doc_code_examples.rs:4:1
--> $DIR/feature-gate-rustdoc_missing_doc_code_examples.rs:4:10
|
LL | #![allow(rustdoc::missing_doc_code_examples)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: the `rustdoc::missing_doc_code_examples` lint is unstable
= note: see issue #101730 <https://github.com/rust-lang/rust/issues/101730> for more information

4
tests/ui/attr-bad-crate-attr.rs
View file

@ -1,4 +0,0 @@
//@ error-pattern: expected item
#![attr = "val"]
#[attr = "val"] // Unterminated

5
tests/ui/attr-shebang.rs
View file

@ -1,5 +0,0 @@
//@ run-pass
#![allow(stable_features)]
#![feature(rust1)]
pub fn main() { }

9
tests/ui/attributes/attr-bad-crate-attr.rs Normal file
View file

@ -0,0 +1,9 @@
//! Check that we permit a crate-level inner attribute but reject a dangling outer attribute which
//! does not have a following thing that it can target.
//!
//! See <https://doc.rust-lang.org/reference/attributes.html>.
//@ error-pattern: expected item
#![attr = "val"]
#[attr = "val"] // Unterminated

2
tests/ui/attr-bad-crate-attr.stderr → tests/ui/attributes/attr-bad-crate-attr.stderr
View file

@ -1,5 +1,5 @@
error: expected item after attributes
--> $DIR/attr-bad-crate-attr.rs:4:1
--> $DIR/attr-bad-crate-attr.rs:9:1
|
LL | #[attr = "val"] // Unterminated
| ^^^^^^^^^^^^^^^

7
tests/ui/attributes/attr-shebang.rs Normal file
View file

@ -0,0 +1,7 @@
//! Check that we accept crate-level inner attributes with the `#![..]` shebang syntax.
//@ check-pass
#![allow(stable_features)]
#![feature(rust1)]
pub fn main() { }

3
tests/ui/attr-usage-inline.rs → tests/ui/attributes/inline/attr-usage-inline.rs
View file

@ -1,4 +1,5 @@
#![allow(dead_code)]
//! Check that `#[inline]` attribute can only be applied to fn-like targets (e.g. function or
//! closure), and when misapplied to other targets an error is emitted.
#[inline]
fn f() {}

4
tests/ui/attr-usage-inline.stderr → tests/ui/attributes/inline/attr-usage-inline.stderr
View file

@ -1,5 +1,5 @@
error[E0518]: attribute should be applied to function or closure
--> $DIR/attr-usage-inline.rs:6:1
--> $DIR/attr-usage-inline.rs:7:1
|
LL | #[inline]
| ^^^^^^^^^
@ -7,7 +7,7 @@ LL | struct S;
| --------- not a function or closure
error[E0518]: attribute should be applied to function or closure
--> $DIR/attr-usage-inline.rs:20:1
--> $DIR/attr-usage-inline.rs:21:1
|
LL | #[inline]
| ^^^^^^^^^ not a function or closure

19
tests/ui/const-generics/generic_const_exprs/specialization-fuzzing-ice-133639.rs Normal file
View file

@ -0,0 +1,19 @@
//@ check-pass
// Regression test for #133639.
#![feature(with_negative_coherence)]
#![feature(min_specialization)]
#![feature(generic_const_exprs)]
//~^ WARNING the feature `generic_const_exprs` is incomplete
#![crate_type = "lib"]
trait Trait {}
struct A<const B: bool>;
trait C {}
impl<const D: u32> Trait for E<D> where A<{ D <= 2 }>: C {}
struct E<const D: u32>;
impl<const D: u32> Trait for E<D> where A<{ D <= 2 }>: C {}

11
tests/ui/const-generics/generic_const_exprs/specialization-fuzzing-ice-133639.stderr Normal file
View file

@ -0,0 +1,11 @@
warning: the feature `generic_const_exprs` is incomplete and may not be safe to use and/or cause compiler crashes
--> $DIR/specialization-fuzzing-ice-133639.rs:7:12
|
LL | #![feature(generic_const_exprs)]
| ^^^^^^^^^^^^^^^^^^^
|
= note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
= note: `#[warn(incomplete_features)]` on by default
warning: 1 warning emitted

3
tests/ui/const-generics/min_const_generics/param-env-eager-norm-dedup.rs
View file

@ -1,3 +1,6 @@
//@ revisions: current next
//@ ignore-compare-mode-next-solver (explicit revisions)
//@[next] compile-flags: -Znext-solver
//@ check-pass
// This caused a regression in a crater run in #132325.

2
tests/ui/diagnostic_namespace/do_not_recommend/as_expression.current.stderr
View file

@ -1,5 +1,5 @@
error[E0277]: the trait bound `&str: AsExpression<Integer>` is not satisfied
--> $DIR/as_expression.rs:57:15
--> $DIR/as_expression.rs:55:15
|
LL | SelectInt.check("bar");
| ^^^^^ the trait `AsExpression<Integer>` is not implemented for `&str`

8
tests/ui/diagnostic_namespace/do_not_recommend/as_expression.next.stderr
View file

@ -1,5 +1,5 @@
error[E0277]: the trait bound `&str: AsExpression<<SelectInt as Expression>::SqlType>` is not satisfied
--> $DIR/as_expression.rs:57:21
--> $DIR/as_expression.rs:55:21
|
LL | SelectInt.check("bar");
| ----- ^^^^^ the trait `AsExpression<<SelectInt as Expression>::SqlType>` is not implemented for `&str`
@ -8,7 +8,7 @@ LL | SelectInt.check("bar");
|
= help: the trait `AsExpression<Text>` is implemented for `&str`
note: required by a bound in `Foo::check`
--> $DIR/as_expression.rs:48:12
--> $DIR/as_expression.rs:46:12
|
LL | fn check<T>(&self, _: T) -> <T as AsExpression<<Self as Expression>::SqlType>>::Expression
| ----- required by a bound in this associated function
@ -17,7 +17,7 @@ LL | T: AsExpression<Self::SqlType>,
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Foo::check`
error[E0277]: the trait bound `&str: AsExpression<Integer>` is not satisfied
--> $DIR/as_expression.rs:57:15
--> $DIR/as_expression.rs:55:15
|
LL | SelectInt.check("bar");
| ^^^^^ the trait `AsExpression<Integer>` is not implemented for `&str`
@ -27,7 +27,7 @@ LL | SelectInt.check("bar");
= help: for that trait implementation, expected `Text`, found `Integer`
error[E0271]: type mismatch resolving `<SelectInt as Expression>::SqlType == Text`
--> $DIR/as_expression.rs:57:5
--> $DIR/as_expression.rs:55:5
|
LL | SelectInt.check("bar");
| ^^^^^^^^^^^^^^^^^^^^^^ expected `Text`, found `Integer`

2
tests/ui/diagnostic_namespace/do_not_recommend/as_expression.rs
View file

@ -2,8 +2,6 @@
//@ ignore-compare-mode-next-solver (explicit revisions)
//@[next] compile-flags: -Znext-solver
#![feature(do_not_recommend)]
pub trait Expression {
type SqlType;
}

21
tests/ui/diagnostic_namespace/do_not_recommend/do_not_apply_attribute_without_feature_flag.rs
View file

@ -1,21 +0,0 @@
#![allow(unknown_or_malformed_diagnostic_attributes)]
trait Foo {}
#[diagnostic::do_not_recommend]
impl<A> Foo for (A,) {}
#[diagnostic::do_not_recommend]
impl<A, B> Foo for (A, B) {}
#[diagnostic::do_not_recommend]
impl<A, B, C> Foo for (A, B, C) {}
impl Foo for i32 {}
fn check(a: impl Foo) {}
fn main() {
check(());
//~^ ERROR the trait bound `(): Foo` is not satisfied
}

25
tests/ui/diagnostic_namespace/do_not_recommend/do_not_apply_attribute_without_feature_flag.stderr
View file

@ -1,25 +0,0 @@
error[E0277]: the trait bound `(): Foo` is not satisfied
--> $DIR/do_not_apply_attribute_without_feature_flag.rs:19:11
|
LL | check(());
| ----- ^^ the trait `Foo` is not implemented for `()`
| |
| required by a bound introduced by this call
|
= help: the following other types implement trait `Foo`:
(A, B)
(A, B, C)
(A,)
note: required by a bound in `check`
--> $DIR/do_not_apply_attribute_without_feature_flag.rs:16:18
|
LL | fn check(a: impl Foo) {}
| ^^^ required by this bound in `check`
help: use a unary tuple instead
|
LL | check(((),));
| + ++
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0277`.

22
tests/ui/diagnostic_namespace/do_not_recommend/does_not_acccept_args.current.stderr Normal file
View file

@ -0,0 +1,22 @@
warning: `#[diagnostic::do_not_recommend]` does not expect any arguments
--> $DIR/does_not_acccept_args.rs:10:1
|
LL | #[diagnostic::do_not_recommend(not_accepted)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: `#[warn(unknown_or_malformed_diagnostic_attributes)]` on by default
warning: `#[diagnostic::do_not_recommend]` does not expect any arguments
--> $DIR/does_not_acccept_args.rs:14:1
|
LL | #[diagnostic::do_not_recommend(not_accepted = "foo")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: `#[diagnostic::do_not_recommend]` does not expect any arguments
--> $DIR/does_not_acccept_args.rs:18:1
|
LL | #[diagnostic::do_not_recommend(not_accepted(42))]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: 3 warnings emitted

22
tests/ui/diagnostic_namespace/do_not_recommend/does_not_acccept_args.next.stderr Normal file
View file

@ -0,0 +1,22 @@
warning: `#[diagnostic::do_not_recommend]` does not expect any arguments
--> $DIR/does_not_acccept_args.rs:10:1
|
LL | #[diagnostic::do_not_recommend(not_accepted)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: `#[warn(unknown_or_malformed_diagnostic_attributes)]` on by default
warning: `#[diagnostic::do_not_recommend]` does not expect any arguments
--> $DIR/does_not_acccept_args.rs:14:1
|
LL | #[diagnostic::do_not_recommend(not_accepted = "foo")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: `#[diagnostic::do_not_recommend]` does not expect any arguments
--> $DIR/does_not_acccept_args.rs:18:1
|
LL | #[diagnostic::do_not_recommend(not_accepted(42))]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: 3 warnings emitted

22
tests/ui/diagnostic_namespace/do_not_recommend/does_not_acccept_args.rs Normal file
View file

@ -0,0 +1,22 @@
//@ check-pass
//@ revisions: current next
//@ ignore-compare-mode-next-solver (explicit revisions)
//@[next] compile-flags: -Znext-solver
trait Foo {}
trait Bar {}
trait Baz {}
#[diagnostic::do_not_recommend(not_accepted)]
//~^ WARNING `#[diagnostic::do_not_recommend]` does not expect any arguments
impl<T> Foo for T where T: Send {}
#[diagnostic::do_not_recommend(not_accepted = "foo")]
//~^ WARNING `#[diagnostic::do_not_recommend]` does not expect any arguments
impl<T> Bar for T where T: Send {}
#[diagnostic::do_not_recommend(not_accepted(42))]
//~^ WARNING `#[diagnostic::do_not_recommend]` does not expect any arguments
impl<T> Baz for T where T: Send {}
fn main() {}

17
tests/ui/diagnostic_namespace/do_not_recommend/feature-gate-do_not_recommend.rs
View file

@ -1,17 +0,0 @@
#![feature(do_not_recommend)]
pub trait Foo {}
impl Foo for i32 {}
pub trait Bar {}
#[diagnostic::do_not_recommend]
impl<T: Foo> Bar for T {}
fn stuff<T: Bar>(_: T) {}
fn main() {
stuff(1u8);
//~^ the trait bound `u8: Bar` is not satisfied
}

15
tests/ui/diagnostic_namespace/do_not_recommend/feature-gate-do_not_recommend.stderr
View file

@ -1,15 +0,0 @@
error[E0277]: the trait bound `u8: Bar` is not satisfied
--> $DIR/feature-gate-do_not_recommend.rs:15:11
|
LL | stuff(1u8);
| ^^^ the trait `Bar` is not implemented for `u8`
|
note: required by a bound in `stuff`
--> $DIR/feature-gate-do_not_recommend.rs:12:13
|
LL | fn stuff<T: Bar>(_: T) {}
| ^^^ required by this bound in `stuff`
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0277`.

24
tests/ui/diagnostic_namespace/do_not_recommend/incorrect-locations.stderr → tests/ui/diagnostic_namespace/do_not_recommend/incorrect-locations.current.stderr
View file

@ -1,5 +1,5 @@
warning: `#[diagnostic::do_not_recommend]` can only be placed on trait implementations
--> $DIR/incorrect-locations.rs:4:1
--> $DIR/incorrect-locations.rs:6:1
|
LL | #[diagnostic::do_not_recommend]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -7,46 +7,52 @@ LL | #[diagnostic::do_not_recommend]
= note: `#[warn(unknown_or_malformed_diagnostic_attributes)]` on by default
warning: `#[diagnostic::do_not_recommend]` can only be placed on trait implementations
--> $DIR/incorrect-locations.rs:8:1
--> $DIR/incorrect-locations.rs:10:1
|
LL | #[diagnostic::do_not_recommend]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: `#[diagnostic::do_not_recommend]` can only be placed on trait implementations
--> $DIR/incorrect-locations.rs:12:1
--> $DIR/incorrect-locations.rs:14:1
|
LL | #[diagnostic::do_not_recommend]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: `#[diagnostic::do_not_recommend]` can only be placed on trait implementations
--> $DIR/incorrect-locations.rs:16:1
--> $DIR/incorrect-locations.rs:18:1
|
LL | #[diagnostic::do_not_recommend]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: `#[diagnostic::do_not_recommend]` can only be placed on trait implementations
--> $DIR/incorrect-locations.rs:20:1
--> $DIR/incorrect-locations.rs:22:1
|
LL | #[diagnostic::do_not_recommend]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: `#[diagnostic::do_not_recommend]` can only be placed on trait implementations
--> $DIR/incorrect-locations.rs:24:1
--> $DIR/incorrect-locations.rs:26:1
|
LL | #[diagnostic::do_not_recommend]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: `#[diagnostic::do_not_recommend]` can only be placed on trait implementations
--> $DIR/incorrect-locations.rs:28:1
--> $DIR/incorrect-locations.rs:30:1
|
LL | #[diagnostic::do_not_recommend]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: `#[diagnostic::do_not_recommend]` can only be placed on trait implementations
--> $DIR/incorrect-locations.rs:32:1
--> $DIR/incorrect-locations.rs:34:1
|
LL | #[diagnostic::do_not_recommend]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: 8 warnings emitted
warning: `#[diagnostic::do_not_recommend]` can only be placed on trait implementations
--> $DIR/incorrect-locations.rs:38:1
|
LL | #[diagnostic::do_not_recommend]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: 9 warnings emitted

58
tests/ui/diagnostic_namespace/do_not_recommend/incorrect-locations.next.stderr Normal file
View file

@ -0,0 +1,58 @@
warning: `#[diagnostic::do_not_recommend]` can only be placed on trait implementations
--> $DIR/incorrect-locations.rs:6:1
|
LL | #[diagnostic::do_not_recommend]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: `#[warn(unknown_or_malformed_diagnostic_attributes)]` on by default
warning: `#[diagnostic::do_not_recommend]` can only be placed on trait implementations
--> $DIR/incorrect-locations.rs:10:1
|
LL | #[diagnostic::do_not_recommend]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: `#[diagnostic::do_not_recommend]` can only be placed on trait implementations
--> $DIR/incorrect-locations.rs:14:1
|
LL | #[diagnostic::do_not_recommend]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: `#[diagnostic::do_not_recommend]` can only be placed on trait implementations
--> $DIR/incorrect-locations.rs:18:1
|
LL | #[diagnostic::do_not_recommend]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: `#[diagnostic::do_not_recommend]` can only be placed on trait implementations
--> $DIR/incorrect-locations.rs:22:1
|
LL | #[diagnostic::do_not_recommend]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: `#[diagnostic::do_not_recommend]` can only be placed on trait implementations
--> $DIR/incorrect-locations.rs:26:1
|
LL | #[diagnostic::do_not_recommend]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: `#[diagnostic::do_not_recommend]` can only be placed on trait implementations
--> $DIR/incorrect-locations.rs:30:1
|
LL | #[diagnostic::do_not_recommend]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: `#[diagnostic::do_not_recommend]` can only be placed on trait implementations
--> $DIR/incorrect-locations.rs:34:1
|
LL | #[diagnostic::do_not_recommend]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: `#[diagnostic::do_not_recommend]` can only be placed on trait implementations
--> $DIR/incorrect-locations.rs:38:1
|
LL | #[diagnostic::do_not_recommend]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
warning: 9 warnings emitted

8
tests/ui/diagnostic_namespace/do_not_recommend/incorrect-locations.rs
View file

@ -1,5 +1,7 @@
//@ check-pass
#![feature(do_not_recommend)]
//@ revisions: current next
//@ ignore-compare-mode-next-solver (explicit revisions)
//@[next] compile-flags: -Znext-solver
#[diagnostic::do_not_recommend]
//~^WARN `#[diagnostic::do_not_recommend]` can only be placed
@ -17,6 +19,10 @@ type Type = ();
//~^WARN `#[diagnostic::do_not_recommend]` can only be placed
enum Enum {}
#[diagnostic::do_not_recommend]
//~^WARN `#[diagnostic::do_not_recommend]` can only be placed
impl Enum {}
#[diagnostic::do_not_recommend]
//~^WARN `#[diagnostic::do_not_recommend]` can only be placed
extern "C" {}

15
tests/ui/diagnostic_namespace/do_not_recommend/nested.current.stderr Normal file
View file

@ -0,0 +1,15 @@
error[E0277]: the trait bound `(): Root` is not satisfied
--> $DIR/nested.rs:21:18
|
LL | needs_root::<()>();
| ^^ the trait `Root` is not implemented for `()`
|
note: required by a bound in `needs_root`
--> $DIR/nested.rs:18:18
|
LL | fn needs_root<T: Root>() {}
| ^^^^ required by this bound in `needs_root`
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0277`.

15
tests/ui/diagnostic_namespace/do_not_recommend/nested.next.stderr Normal file
View file

@ -0,0 +1,15 @@
error[E0277]: the trait bound `(): Root` is not satisfied
--> $DIR/nested.rs:21:18
|
LL | needs_root::<()>();
| ^^ the trait `Root` is not implemented for `()`
|
note: required by a bound in `needs_root`
--> $DIR/nested.rs:18:18
|
LL | fn needs_root<T: Root>() {}
| ^^^^ required by this bound in `needs_root`
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0277`.

23
tests/ui/diagnostic_namespace/do_not_recommend/nested.rs Normal file
View file

@ -0,0 +1,23 @@
//@ revisions: current next
//@ ignore-compare-mode-next-solver (explicit revisions)
//@[next] compile-flags: -Znext-solver
trait Root {}
trait DontRecommend {}
trait Other {}
trait Child {}
#[diagnostic::do_not_recommend]
impl<T> Root for T where T: DontRecommend {}
impl<T> DontRecommend for T where T: Other {}
#[diagnostic::do_not_recommend]
impl<T> Other for T where T: Child {}
fn needs_root<T: Root>() {}
fn main() {
needs_root::<()>();
//~^ ERROR the trait bound `(): Root` is not satisfied
}

4
tests/ui/diagnostic_namespace/do_not_recommend/simple.current.stderr
View file

@ -1,11 +1,11 @@
error[E0277]: the trait bound `*mut (): Foo` is not satisfied
--> $DIR/simple.rs:17:17
--> $DIR/simple.rs:15:17
|
LL | needs_foo::<*mut ()>();
| ^^^^^^^ the trait `Foo` is not implemented for `*mut ()`
|
note: required by a bound in `needs_foo`
--> $DIR/simple.rs:12:17
--> $DIR/simple.rs:10:17
|
LL | fn needs_foo<T: Foo>() {}
| ^^^ required by this bound in `needs_foo`

4
tests/ui/diagnostic_namespace/do_not_recommend/simple.next.stderr
View file

@ -1,11 +1,11 @@
error[E0277]: the trait bound `*mut (): Foo` is not satisfied
--> $DIR/simple.rs:17:17
--> $DIR/simple.rs:15:17
|
LL | needs_foo::<*mut ()>();
| ^^^^^^^ the trait `Foo` is not implemented for `*mut ()`
|
note: required by a bound in `needs_foo`
--> $DIR/simple.rs:12:17
--> $DIR/simple.rs:10:17
|
LL | fn needs_foo<T: Foo>() {}
| ^^^ required by this bound in `needs_foo`

2
tests/ui/diagnostic_namespace/do_not_recommend/simple.rs
View file

@ -2,8 +2,6 @@
//@ ignore-compare-mode-next-solver (explicit revisions)
//@[next] compile-flags: -Znext-solver
#![feature(do_not_recommend)]
trait Foo {}
#[diagnostic::do_not_recommend]

4
tests/ui/diagnostic_namespace/do_not_recommend/stacked.current.stderr
View file

@ -1,11 +1,11 @@
error[E0277]: the trait bound `(): Root` is not satisfied
--> $DIR/stacked.rs:19:18
--> $DIR/stacked.rs:17:18
|
LL | needs_root::<()>();
| ^^ the trait `Root` is not implemented for `()`
|
note: required by a bound in `needs_root`
--> $DIR/stacked.rs:16:18
--> $DIR/stacked.rs:14:18
|
LL | fn needs_root<T: Root>() {}
| ^^^^ required by this bound in `needs_root`

4
tests/ui/diagnostic_namespace/do_not_recommend/stacked.next.stderr
View file

@ -1,11 +1,11 @@
error[E0277]: the trait bound `(): Root` is not satisfied
--> $DIR/stacked.rs:19:18
--> $DIR/stacked.rs:17:18
|
LL | needs_root::<()>();
| ^^ the trait `Root` is not implemented for `()`
|
note: required by a bound in `needs_root`
--> $DIR/stacked.rs:16:18
--> $DIR/stacked.rs:14:18
|
LL | fn needs_root<T: Root>() {}
| ^^^^ required by this bound in `needs_root`

2
tests/ui/diagnostic_namespace/do_not_recommend/stacked.rs
View file

@ -2,8 +2,6 @@
//@ ignore-compare-mode-next-solver (explicit revisions)
//@[next] compile-flags: -Znext-solver
#![feature(do_not_recommend)]
trait Root {}
trait DontRecommend {}
trait Other {}

4
tests/ui/diagnostic_namespace/do_not_recommend/supress_suggestions_in_help.current.stderr
View file

@ -1,5 +1,5 @@
error[E0277]: the trait bound `(): Foo` is not satisfied
--> $DIR/supress_suggestions_in_help.rs:23:11
--> $DIR/supress_suggestions_in_help.rs:21:11
|
LL | check(());
| ----- ^^ the trait `Foo` is not implemented for `()`
@ -8,7 +8,7 @@ LL | check(());
|
= help: the trait `Foo` is implemented for `i32`
note: required by a bound in `check`
--> $DIR/supress_suggestions_in_help.rs:20:18
--> $DIR/supress_suggestions_in_help.rs:18:18
|
LL | fn check(a: impl Foo) {}
| ^^^ required by this bound in `check`

4
tests/ui/diagnostic_namespace/do_not_recommend/supress_suggestions_in_help.next.stderr
View file

@ -1,5 +1,5 @@
error[E0277]: the trait bound `(): Foo` is not satisfied
--> $DIR/supress_suggestions_in_help.rs:23:11
--> $DIR/supress_suggestions_in_help.rs:21:11
|
LL | check(());
| ----- ^^ the trait `Foo` is not implemented for `()`
@ -8,7 +8,7 @@ LL | check(());
|
= help: the trait `Foo` is implemented for `i32`
note: required by a bound in `check`
--> $DIR/supress_suggestions_in_help.rs:20:18
--> $DIR/supress_suggestions_in_help.rs:18:18
|
LL | fn check(a: impl Foo) {}
| ^^^ required by this bound in `check`

2
tests/ui/diagnostic_namespace/do_not_recommend/supress_suggestions_in_help.rs
View file

@ -2,8 +2,6 @@
//@ ignore-compare-mode-next-solver (explicit revisions)
//@[next] compile-flags: -Znext-solver
#![feature(do_not_recommend)]
trait Foo {}
#[diagnostic::do_not_recommend]

4
tests/ui/diagnostic_namespace/do_not_recommend/type_mismatch.current.stderr
View file

@ -1,11 +1,11 @@
error[E0277]: Very important message!
--> $DIR/type_mismatch.rs:25:14
--> $DIR/type_mismatch.rs:23:14
|
LL | verify::<u8>();
| ^^ the trait `TheImportantOne` is not implemented for `u8`
|
note: required by a bound in `verify`
--> $DIR/type_mismatch.rs:22:14
--> $DIR/type_mismatch.rs:20:14
|
LL | fn verify<T: TheImportantOne>() {}
| ^^^^^^^^^^^^^^^ required by this bound in `verify`

4
tests/ui/diagnostic_namespace/do_not_recommend/type_mismatch.next.stderr
View file

@ -1,11 +1,11 @@
error[E0277]: Very important message!
--> $DIR/type_mismatch.rs:25:14
--> $DIR/type_mismatch.rs:23:14
|
LL | verify::<u8>();
| ^^ the trait `TheImportantOne` is not implemented for `u8`
|
note: required by a bound in `verify`
--> $DIR/type_mismatch.rs:22:14
--> $DIR/type_mismatch.rs:20:14
|
LL | fn verify<T: TheImportantOne>() {}
| ^^^^^^^^^^^^^^^ required by this bound in `verify`

2
tests/ui/diagnostic_namespace/do_not_recommend/type_mismatch.rs
View file

@ -2,8 +2,6 @@
//@ ignore-compare-mode-next-solver (explicit revisions)
//@[next] compile-flags: -Znext-solver
#![feature(do_not_recommend)]
#[diagnostic::on_unimplemented(message = "Very important message!")]
trait TheImportantOne {}

8
tests/ui/diagnostic_namespace/do_not_recommend/unstable-feature.rs
View file

@ -1,8 +0,0 @@
#![deny(unknown_or_malformed_diagnostic_attributes)]
trait Foo {}
#[diagnostic::do_not_recommend]
//~^ ERROR unknown diagnostic attribute [unknown_or_malformed_diagnostic_attributes]
impl Foo for i32 {}
fn main() {}

14
tests/ui/diagnostic_namespace/do_not_recommend/unstable-feature.stderr
View file

@ -1,14 +0,0 @@
error: unknown diagnostic attribute
--> $DIR/unstable-feature.rs:4:15
|
LL | #[diagnostic::do_not_recommend]
| ^^^^^^^^^^^^^^^^
|
note: the lint level is defined here
--> $DIR/unstable-feature.rs:1:9
|
LL | #![deny(unknown_or_malformed_diagnostic_attributes)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to 1 previous error

10
tests/ui/diagnostic_namespace/do_not_recommend/with_lifetime.current.stderr Normal file
View file

@ -0,0 +1,10 @@
error: lifetime may not live long enough
--> $DIR/with_lifetime.rs:17:5
|
LL | fn foo<'a>(a: &'a ()) {
| -- lifetime `'a` defined here
LL | needs_root::<&'a ()>();
| ^^^^^^^^^^^^^^^^^^^^ requires that `'a` must outlive `'static`
error: aborting due to 1 previous error

10
tests/ui/diagnostic_namespace/do_not_recommend/with_lifetime.next.stderr Normal file
View file

@ -0,0 +1,10 @@
error: lifetime may not live long enough
--> $DIR/with_lifetime.rs:17:5
|
LL | fn foo<'a>(a: &'a ()) {
| -- lifetime `'a` defined here
LL | needs_root::<&'a ()>();
| ^^^^^^^^^^^^^^^^^^^^ requires that `'a` must outlive `'static`
error: aborting due to 1 previous error

23
tests/ui/diagnostic_namespace/do_not_recommend/with_lifetime.rs Normal file
View file

@ -0,0 +1,23 @@
//@ revisions: current next
//@ ignore-compare-mode-next-solver (explicit revisions)
//@[next] compile-flags: -Znext-solver
trait Root {}
trait DontRecommend {}
impl<T> Root for T where T: DontRecommend {}
// this has no effect yet for resolving the trait error below
#[diagnostic::do_not_recommend]
impl<T> DontRecommend for &'static T {}
fn needs_root<T: Root>() {}
fn foo<'a>(a: &'a ()) {
needs_root::<&'a ()>();
//~^ ERROR lifetime may not live long enough
}
fn main() {
foo(&());
}

8
tests/ui/feature-gates/feature-gate-multiple_supertrait_upcastable.stderr
View file

@ -1,8 +1,8 @@
warning: unknown lint: `multiple_supertrait_upcastable`
--> $DIR/feature-gate-multiple_supertrait_upcastable.rs:3:1
--> $DIR/feature-gate-multiple_supertrait_upcastable.rs:3:9
|
LL | #![deny(multiple_supertrait_upcastable)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: the `multiple_supertrait_upcastable` lint is unstable
= help: add `#![feature(multiple_supertrait_upcastable)]` to the crate attributes to enable
@ -10,10 +10,10 @@ LL | #![deny(multiple_supertrait_upcastable)]
= note: `#[warn(unknown_lints)]` on by default
warning: unknown lint: `multiple_supertrait_upcastable`
--> $DIR/feature-gate-multiple_supertrait_upcastable.rs:5:1
--> $DIR/feature-gate-multiple_supertrait_upcastable.rs:5:9
|
LL | #![warn(multiple_supertrait_upcastable)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: the `multiple_supertrait_upcastable` lint is unstable
= help: add `#![feature(multiple_supertrait_upcastable)]` to the crate attributes to enable

24
tests/ui/feature-gates/feature-gate-non_exhaustive_omitted_patterns_lint.stderr
View file

@ -1,8 +1,8 @@
warning: unknown lint: `non_exhaustive_omitted_patterns`
--> $DIR/feature-gate-non_exhaustive_omitted_patterns_lint.rs:3:1
--> $DIR/feature-gate-non_exhaustive_omitted_patterns_lint.rs:3:9
|
LL | #![deny(non_exhaustive_omitted_patterns)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: the `non_exhaustive_omitted_patterns` lint is unstable
= note: see issue #89554 <https://github.com/rust-lang/rust/issues/89554> for more information
@ -11,10 +11,10 @@ LL | #![deny(non_exhaustive_omitted_patterns)]
= note: `#[warn(unknown_lints)]` on by default
warning: unknown lint: `non_exhaustive_omitted_patterns`
--> $DIR/feature-gate-non_exhaustive_omitted_patterns_lint.rs:5:1
--> $DIR/feature-gate-non_exhaustive_omitted_patterns_lint.rs:5:10
|
LL | #![allow(non_exhaustive_omitted_patterns)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: the `non_exhaustive_omitted_patterns` lint is unstable
= note: see issue #89554 <https://github.com/rust-lang/rust/issues/89554> for more information
@ -22,10 +22,10 @@ LL | #![allow(non_exhaustive_omitted_patterns)]
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
warning: unknown lint: `non_exhaustive_omitted_patterns`
--> $DIR/feature-gate-non_exhaustive_omitted_patterns_lint.rs:15:5
--> $DIR/feature-gate-non_exhaustive_omitted_patterns_lint.rs:15:13
|
LL | #[allow(non_exhaustive_omitted_patterns)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: the `non_exhaustive_omitted_patterns` lint is unstable
= note: see issue #89554 <https://github.com/rust-lang/rust/issues/89554> for more information
@ -33,10 +33,10 @@ LL | #[allow(non_exhaustive_omitted_patterns)]
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
warning: unknown lint: `non_exhaustive_omitted_patterns`
--> $DIR/feature-gate-non_exhaustive_omitted_patterns_lint.rs:15:5
--> $DIR/feature-gate-non_exhaustive_omitted_patterns_lint.rs:15:13
|
LL | #[allow(non_exhaustive_omitted_patterns)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: the `non_exhaustive_omitted_patterns` lint is unstable
= note: see issue #89554 <https://github.com/rust-lang/rust/issues/89554> for more information
@ -45,10 +45,10 @@ LL | #[allow(non_exhaustive_omitted_patterns)]
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
warning: unknown lint: `non_exhaustive_omitted_patterns`
--> $DIR/feature-gate-non_exhaustive_omitted_patterns_lint.rs:24:5
--> $DIR/feature-gate-non_exhaustive_omitted_patterns_lint.rs:24:12
|
LL | #[warn(non_exhaustive_omitted_patterns)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: the `non_exhaustive_omitted_patterns` lint is unstable
= note: see issue #89554 <https://github.com/rust-lang/rust/issues/89554> for more information
@ -56,10 +56,10 @@ LL | #[warn(non_exhaustive_omitted_patterns)]
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
warning: unknown lint: `non_exhaustive_omitted_patterns`
--> $DIR/feature-gate-non_exhaustive_omitted_patterns_lint.rs:24:5
--> $DIR/feature-gate-non_exhaustive_omitted_patterns_lint.rs:24:12
|
LL | #[warn(non_exhaustive_omitted_patterns)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: the `non_exhaustive_omitted_patterns` lint is unstable
= note: see issue #89554 <https://github.com/rust-lang/rust/issues/89554> for more information

8
tests/ui/feature-gates/feature-gate-strict_provenance_lints.stderr
View file

@ -1,8 +1,8 @@
warning: unknown lint: `fuzzy_provenance_casts`
--> $DIR/feature-gate-strict_provenance_lints.rs:3:1
--> $DIR/feature-gate-strict_provenance_lints.rs:3:9
|
LL | #![deny(fuzzy_provenance_casts)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^^^
|
= note: the `fuzzy_provenance_casts` lint is unstable
= note: see issue #130351 <https://github.com/rust-lang/rust/issues/130351> for more information
@ -11,10 +11,10 @@ LL | #![deny(fuzzy_provenance_casts)]
= note: `#[warn(unknown_lints)]` on by default
warning: unknown lint: `lossy_provenance_casts`
--> $DIR/feature-gate-strict_provenance_lints.rs:5:1
--> $DIR/feature-gate-strict_provenance_lints.rs:5:9
|
LL | #![deny(lossy_provenance_casts)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^^^
|
= note: the `lossy_provenance_casts` lint is unstable
= note: see issue #130351 <https://github.com/rust-lang/rust/issues/130351> for more information

4
tests/ui/feature-gates/feature-gate-test_unstable_lint.stderr
View file

@ -1,8 +1,8 @@
warning: unknown lint: `test_unstable_lint`
--> $DIR/feature-gate-test_unstable_lint.rs:4:1
--> $DIR/feature-gate-test_unstable_lint.rs:4:10
|
LL | #![allow(test_unstable_lint)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^
|
= note: the `test_unstable_lint` lint is unstable
= help: add `#![feature(test_unstable_lint)]` to the crate attributes to enable

4
tests/ui/feature-gates/feature-gate-unqualified-local-imports.stderr
View file

@ -1,8 +1,8 @@
warning: unknown lint: `unqualified_local_imports`
--> $DIR/feature-gate-unqualified-local-imports.rs:3:1
--> $DIR/feature-gate-unqualified-local-imports.rs:3:10
|
LL | #![allow(unqualified_local_imports)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: the `unqualified_local_imports` lint is unstable
= help: add `#![feature(unqualified_local_imports)]` to the crate attributes to enable

9
tests/ui/higher-ranked/trait-bounds/normalize-under-binder/norm-before-method-resolution-opaque-type.next.stderr
View file

@ -1,9 +0,0 @@
error[E0284]: type annotations needed: cannot satisfy `Foo == _`
--> $DIR/norm-before-method-resolution-opaque-type.rs:15:19
|
LL | fn weird_bound<X>(x: &<X as Trait<'static>>::Out<Foo>) -> X
| ^ cannot satisfy `Foo == _`
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0284`.

4
tests/ui/higher-ranked/trait-bounds/normalize-under-binder/norm-before-method-resolution-opaque-type.old.stderr
View file

@ -1,12 +1,12 @@
error: item does not constrain `Foo::{opaque#0}`, but has it in its signature
--> $DIR/norm-before-method-resolution-opaque-type.rs:15:4
--> $DIR/norm-before-method-resolution-opaque-type.rs:16:4
|
LL | fn weird_bound<X>(x: &<X as Trait<'static>>::Out<Foo>) -> X
| ^^^^^^^^^^^
|
= note: consider moving the opaque type's declaration and defining uses into a separate module
note: this opaque type is in the signature
--> $DIR/norm-before-method-resolution-opaque-type.rs:13:12
--> $DIR/norm-before-method-resolution-opaque-type.rs:14:12
|
LL | type Foo = impl Sized;
| ^^^^^^^^^^

2
tests/ui/higher-ranked/trait-bounds/normalize-under-binder/norm-before-method-resolution-opaque-type.rs
View file

@ -1,5 +1,6 @@
//@ revisions: old next
//@[next] compile-flags: -Znext-solver
//@[next] check-pass
#![feature(type_alias_impl_trait)]
trait Trait<'a> {
@ -14,7 +15,6 @@ type Foo = impl Sized;
fn weird_bound<X>(x: &<X as Trait<'static>>::Out<Foo>) -> X
//[old]~^ ERROR: item does not constrain
//[next]~^^ ERROR: cannot satisfy `Foo == _`
where
for<'a> X: Trait<'a>,
for<'a> <X as Trait<'a>>::Out<()>: Copy,

4
tests/ui/lint/must_not_suspend/gated.stderr
View file

@ -1,8 +1,8 @@
warning: unknown lint: `must_not_suspend`
--> $DIR/gated.rs:4:1
--> $DIR/gated.rs:4:9
|
LL | #![deny(must_not_suspend)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^
|
= note: the `must_not_suspend` lint is unstable
= note: see issue #83310 <https://github.com/rust-lang/rust/issues/83310> for more information

0
tests/ui/associated-path-shl.rs → tests/ui/parser/associated-path-shl.rs
View file

0
tests/ui/associated-path-shl.stderr → tests/ui/parser/associated-path-shl.stderr
View file

11
tests/ui/attrs-resolution-errors.rs → tests/ui/resolve/attr-macros-positional-rejection.rs
View file

@ -1,3 +1,12 @@
//! Check that certain positions (listed below) only permit *non-macro* attributes and reject
//! attribute macros:
//!
//! - Enum variants
//! - Struct fields
//! - Field in a struct pattern
//! - Match arm
//! - Field in struct initialization expression
enum FooEnum {
#[test]
//~^ ERROR expected non-macro attribute, found attribute macro
@ -32,7 +41,7 @@ fn main() {
_ => {}
}
let _another_foo_strunct = FooStruct {
let _another_foo_struct = FooStruct {
#[test]
//~^ ERROR expected non-macro attribute, found attribute macro
bar: 1,

10
tests/ui/attrs-resolution-errors.stderr → tests/ui/resolve/attr-macros-positional-rejection.stderr
View file

@ -1,29 +1,29 @@
error: expected non-macro attribute, found attribute macro `test`
--> $DIR/attrs-resolution-errors.rs:2:7
--> $DIR/attr-macros-positional-rejection.rs:11:7
|
LL | #[test]
| ^^^^ not a non-macro attribute
error: expected non-macro attribute, found attribute macro `test`
--> $DIR/attrs-resolution-errors.rs:8:7
--> $DIR/attr-macros-positional-rejection.rs:17:7
|
LL | #[test]
| ^^^^ not a non-macro attribute
error: expected non-macro attribute, found attribute macro `test`
--> $DIR/attrs-resolution-errors.rs:23:15
--> $DIR/attr-macros-positional-rejection.rs:32:15
|
LL | #[test] bar
| ^^^^ not a non-macro attribute
error: expected non-macro attribute, found attribute macro `test`
--> $DIR/attrs-resolution-errors.rs:30:11
--> $DIR/attr-macros-positional-rejection.rs:39:11
|
LL | #[test]
| ^^^^ not a non-macro attribute
error: expected non-macro attribute, found attribute macro `test`
--> $DIR/attrs-resolution-errors.rs:36:11
--> $DIR/attr-macros-positional-rejection.rs:45:11
|
LL | #[test]
| ^^^^ not a non-macro attribute

10
tests/ui/attrs-resolution.rs → tests/ui/resolve/non-macro-attrs-accepted.rs
View file

@ -1,3 +1,11 @@
//! Check that certain positions (listed below) permit *non-macro* attributes.
//!
//! - Enum variants
//! - Struct fields
//! - Field in a struct pattern
//! - Match arm
//! - Field in struct initialization expression
//@ check-pass
enum FooEnum {
@ -30,7 +38,7 @@ fn main() {
_ => {}
}
let _another_foo_strunct = FooStruct {
let _another_foo_struct = FooStruct {
#[rustfmt::skip]
bar: 1,
};

5
tests/ui/traits/next-solver/generalize/occurs-check-nested-alias.rs
View file

@ -37,9 +37,4 @@ fn foo<T: Unnormalizable>() {
// result in a cyclic type. However, we can still unify these types by first
// normalizing the inner associated type. Emitting an error here would be incomplete.
drop::<T>(t);
// FIXME(-Znext-solver): This line is necessary due to an unrelated solver bug
// and should get removed in the future.
// https://github.com/rust-lang/trait-system-refactor-initiative/issues/96
drop::<Inv<<T as Unnormalizable>::Assoc>>(u);
}

3
tests/ui/traits/winnowing/global-non-global-env-1.rs
View file

@ -1,3 +1,6 @@
//@ revisions: current next
//@ ignore-compare-mode-next-solver (explicit revisions)
//@[next] compile-flags: -Znext-solver
//@ check-pass
// A regression test for an edge case of candidate selection

3
tests/ui/traits/winnowing/global-non-global-env-2.rs
View file

@ -1,3 +1,6 @@
//@ revisions: current next
//@ ignore-compare-mode-next-solver (explicit revisions)
//@[next] compile-flags: -Znext-solver
//@ check-pass
// A regression test for an edge case of candidate selection

3
tests/ui/traits/winnowing/global-non-global-env-3.rs
View file

@ -1,3 +1,6 @@
//@ revisions: current next
//@ ignore-compare-mode-next-solver (explicit revisions)
//@[next] compile-flags: -Znext-solver
//@ check-pass
// A regression test for an edge case of candidate selection

3
tests/ui/traits/winnowing/global-non-global-env-4.rs
View file

@ -1,3 +1,6 @@
//@ revisions: current next
//@ ignore-compare-mode-next-solver (explicit revisions)
//@[next] compile-flags: -Znext-solver
//@ check-pass
// A regression test for an edge case of candidate selection

0
tests/ui/attempted-access-non-fatal.rs → tests/ui/typeck/attempted-access-non-fatal.rs
View file

0
tests/ui/attempted-access-non-fatal.stderr → tests/ui/typeck/attempted-access-non-fatal.stderr
View file

4
tests/ui/unknown-unstable-lints/deny-unstable-lint-inline.stderr
View file

@ -1,8 +1,8 @@
error: unknown lint: `test_unstable_lint`
--> $DIR/deny-unstable-lint-inline.rs:4:1
--> $DIR/deny-unstable-lint-inline.rs:4:10
|
LL | #![allow(test_unstable_lint)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^
|
= note: the `test_unstable_lint` lint is unstable
= help: add `#![feature(test_unstable_lint)]` to the crate attributes to enable

4
tests/ui/unknown-unstable-lints/warn-unknown-unstable-lint-inline.stderr
View file

@ -1,8 +1,8 @@
warning: unknown lint: `test_unstable_lint`
--> $DIR/warn-unknown-unstable-lint-inline.rs:4:1
--> $DIR/warn-unknown-unstable-lint-inline.rs:4:10
|
LL | #![allow(test_unstable_lint)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^
|
= note: the `test_unstable_lint` lint is unstable
= help: add `#![feature(test_unstable_lint)]` to the crate attributes to enable

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