diff --git a/compiler/rustc_driver/src/lib.rs b/compiler/rustc_driver/src/lib.rs
index 326fefa59ab05..84dd69ebd9634 100644
--- a/compiler/rustc_driver/src/lib.rs
+++ b/compiler/rustc_driver/src/lib.rs
@@ -764,13 +764,7 @@ pub fn version(binary: &str, matches: &getopts::Matches) {
println!("release: {}", unw(util::release_str()));
let debug_flags = matches.opt_strs("Z");
- let backend_name = debug_flags.iter().find_map(|x| {
- if x.starts_with("codegen-backend=") {
- Some(&x["codegen-backends=".len()..])
- } else {
- None
- }
- });
+ let backend_name = debug_flags.iter().find_map(|x| x.strip_prefix("codegen-backend="));
get_codegen_backend(&None, backend_name).print_version();
}
}
diff --git a/compiler/rustc_expand/src/mbe/macro_rules.rs b/compiler/rustc_expand/src/mbe/macro_rules.rs
index b97593b92b355..9aee86c9e57dd 100644
--- a/compiler/rustc_expand/src/mbe/macro_rules.rs
+++ b/compiler/rustc_expand/src/mbe/macro_rules.rs
@@ -45,6 +45,8 @@ crate struct ParserAnyMacro<'a> {
lint_node_id: NodeId,
is_trailing_mac: bool,
arm_span: Span,
+ /// Whether or not this macro is defined in the current crate
+ is_local: bool,
}
crate fn annotate_err_with_kind(
@@ -124,6 +126,7 @@ impl<'a> ParserAnyMacro<'a> {
lint_node_id,
arm_span,
is_trailing_mac,
+ is_local,
} = *self;
let snapshot = &mut parser.clone();
let fragment = match parse_ast_fragment(parser, kind) {
@@ -138,13 +141,15 @@ impl<'a> ParserAnyMacro<'a> {
// `macro_rules! m { () => { panic!(); } }` isn't parsed by `.parse_expr()`,
// but `m!()` is allowed in expression positions (cf. issue #34706).
if kind == AstFragmentKind::Expr && parser.token == token::Semi {
- parser.sess.buffer_lint_with_diagnostic(
- SEMICOLON_IN_EXPRESSIONS_FROM_MACROS,
- parser.token.span,
- lint_node_id,
- "trailing semicolon in macro used in expression position",
- BuiltinLintDiagnostics::TrailingMacro(is_trailing_mac, macro_ident),
- );
+ if is_local {
+ parser.sess.buffer_lint_with_diagnostic(
+ SEMICOLON_IN_EXPRESSIONS_FROM_MACROS,
+ parser.token.span,
+ lint_node_id,
+ "trailing semicolon in macro used in expression position",
+ BuiltinLintDiagnostics::TrailingMacro(is_trailing_mac, macro_ident),
+ );
+ }
parser.bump();
}
@@ -162,6 +167,7 @@ struct MacroRulesMacroExpander {
lhses: Vec<mbe::TokenTree>,
rhses: Vec<mbe::TokenTree>,
valid: bool,
+ is_local: bool,
}
impl TTMacroExpander for MacroRulesMacroExpander {
@@ -183,6 +189,7 @@ impl TTMacroExpander for MacroRulesMacroExpander {
input,
&self.lhses,
&self.rhses,
+ self.is_local,
)
}
}
@@ -210,6 +217,7 @@ fn generic_extension<'cx>(
arg: TokenStream,
lhses: &[mbe::TokenTree],
rhses: &[mbe::TokenTree],
+ is_local: bool,
) -> Box<dyn MacResult + 'cx> {
let sess = &cx.sess.parse_sess;
@@ -311,6 +319,7 @@ fn generic_extension<'cx>(
lint_node_id: cx.current_expansion.lint_node_id,
is_trailing_mac: cx.current_expansion.is_trailing_mac,
arm_span,
+ is_local,
});
}
Failure(token, msg) => match best_failure {
@@ -544,6 +553,9 @@ pub fn compile_declarative_macro(
lhses,
rhses,
valid,
+ // Macros defined in the current crate have a real node id,
+ // whereas macros from an external crate have a dummy id.
+ is_local: def.id != DUMMY_NODE_ID,
}))
}
diff --git a/compiler/rustc_feature/src/removed.rs b/compiler/rustc_feature/src/removed.rs
index 0aa7e82c20492..f63c207a540c2 100644
--- a/compiler/rustc_feature/src/removed.rs
+++ b/compiler/rustc_feature/src/removed.rs
@@ -153,7 +153,7 @@ declare_features! (
Some("the implementation was not maintainable, the feature may get reintroduced once the current refactorings are done")),
/// Allows the use of type alias impl trait in function return positions
- (removed, min_type_alias_impl_trait, "1.55.0", Some(63063), None,
+ (removed, min_type_alias_impl_trait, "1.56.0", Some(63063), None,
Some("removed in favor of full type_alias_impl_trait")),
// -------------------------------------------------------------------------
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index db7fe6cb12ff1..6a533b586cd33 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -2750,6 +2750,15 @@ pub enum Constness {
NotConst,
}
+impl fmt::Display for Constness {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.write_str(match *self {
+ Self::Const => "const",
+ Self::NotConst => "non-const",
+ })
+ }
+}
+
#[derive(Copy, Clone, Encodable, Debug, HashStable_Generic)]
pub struct FnHeader {
pub unsafety: Unsafety,
@@ -3251,8 +3260,13 @@ impl<'hir> Node<'hir> {
}
}
- /// Returns `Constness::Const` when this node is a const fn/impl.
- pub fn constness(&self) -> Constness {
+ /// Returns `Constness::Const` when this node is a const fn/impl/item,
+ ///
+ /// HACK(fee1-dead): or an associated type in a trait. This works because
+ /// only typeck cares about const trait predicates, so although the predicates
+ /// query would return const predicates when it does not need to be const,
+ /// it wouldn't have any effect.
+ pub fn constness_for_typeck(&self) -> Constness {
match self {
Node::Item(Item {
kind: ItemKind::Fn(FnSig { header: FnHeader { constness, .. }, .. }, ..),
@@ -3268,6 +3282,11 @@ impl<'hir> Node<'hir> {
})
| Node::Item(Item { kind: ItemKind::Impl(Impl { constness, .. }), .. }) => *constness,
+ Node::Item(Item { kind: ItemKind::Const(..), .. })
+ | Node::TraitItem(TraitItem { kind: TraitItemKind::Const(..), .. })
+ | Node::TraitItem(TraitItem { kind: TraitItemKind::Type(..), .. })
+ | Node::ImplItem(ImplItem { kind: ImplItemKind::Const(..), .. }) => Constness::Const,
+
_ => Constness::NotConst,
}
}
diff --git a/compiler/rustc_infer/src/traits/engine.rs b/compiler/rustc_infer/src/traits/engine.rs
index 2710debea9478..d60388b31c13c 100644
--- a/compiler/rustc_infer/src/traits/engine.rs
+++ b/compiler/rustc_infer/src/traits/engine.rs
@@ -1,5 +1,6 @@
use crate::infer::InferCtxt;
use crate::traits::Obligation;
+use rustc_hir as hir;
use rustc_hir::def_id::DefId;
use rustc_middle::ty::{self, ToPredicate, Ty, WithConstness};
@@ -49,11 +50,28 @@ pub trait TraitEngine<'tcx>: 'tcx {
infcx: &InferCtxt<'_, 'tcx>,
) -> Result<(), Vec<FulfillmentError<'tcx>>>;
+ fn select_all_with_constness_or_error(
+ &mut self,
+ infcx: &InferCtxt<'_, 'tcx>,
+ _constness: hir::Constness,
+ ) -> Result<(), Vec<FulfillmentError<'tcx>>> {
+ self.select_all_or_error(infcx)
+ }
+
fn select_where_possible(
&mut self,
infcx: &InferCtxt<'_, 'tcx>,
) -> Result<(), Vec<FulfillmentError<'tcx>>>;
+ // FIXME this should not provide a default body for chalk as chalk should be updated
+ fn select_with_constness_where_possible(
+ &mut self,
+ infcx: &InferCtxt<'_, 'tcx>,
+ _constness: hir::Constness,
+ ) -> Result<(), Vec<FulfillmentError<'tcx>>> {
+ self.select_where_possible(infcx)
+ }
+
fn pending_obligations(&self) -> Vec<PredicateObligation<'tcx>>;
}
diff --git a/compiler/rustc_infer/src/traits/util.rs b/compiler/rustc_infer/src/traits/util.rs
index ce1445f8a4746..3139e12116373 100644
--- a/compiler/rustc_infer/src/traits/util.rs
+++ b/compiler/rustc_infer/src/traits/util.rs
@@ -124,7 +124,7 @@ impl Elaborator<'tcx> {
let bound_predicate = obligation.predicate.kind();
match bound_predicate.skip_binder() {
- ty::PredicateKind::Trait(data, _) => {
+ ty::PredicateKind::Trait(data) => {
// Get predicates declared on the trait.
let predicates = tcx.super_predicates_of(data.def_id());
diff --git a/compiler/rustc_lint/src/traits.rs b/compiler/rustc_lint/src/traits.rs
index e713ce7c71bec..2c039b6d05d29 100644
--- a/compiler/rustc_lint/src/traits.rs
+++ b/compiler/rustc_lint/src/traits.rs
@@ -87,7 +87,7 @@ impl<'tcx> LateLintPass<'tcx> for DropTraitConstraints {
let predicates = cx.tcx.explicit_predicates_of(item.def_id);
for &(predicate, span) in predicates.predicates {
let trait_predicate = match predicate.kind().skip_binder() {
- Trait(trait_predicate, _constness) => trait_predicate,
+ Trait(trait_predicate) => trait_predicate,
_ => continue,
};
let def_id = trait_predicate.trait_ref.def_id;
diff --git a/compiler/rustc_lint/src/unused.rs b/compiler/rustc_lint/src/unused.rs
index c431c048ca01c..f4191b883ba48 100644
--- a/compiler/rustc_lint/src/unused.rs
+++ b/compiler/rustc_lint/src/unused.rs
@@ -203,7 +203,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedResults {
let mut has_emitted = false;
for &(predicate, _) in cx.tcx.explicit_item_bounds(def) {
// We only look at the `DefId`, so it is safe to skip the binder here.
- if let ty::PredicateKind::Trait(ref poly_trait_predicate, _) =
+ if let ty::PredicateKind::Trait(ref poly_trait_predicate) =
predicate.kind().skip_binder()
{
let def_id = poly_trait_predicate.trait_ref.def_id;
diff --git a/compiler/rustc_lint_defs/src/builtin.rs b/compiler/rustc_lint_defs/src/builtin.rs
index 5b1cd0bcb3ffe..7195c41eae92e 100644
--- a/compiler/rustc_lint_defs/src/builtin.rs
+++ b/compiler/rustc_lint_defs/src/builtin.rs
@@ -2799,7 +2799,7 @@ declare_lint! {
/// [issue #79813]: https://github.com/rust-lang/rust/issues/79813
/// [future-incompatible]: ../index.md#future-incompatible-lints
pub SEMICOLON_IN_EXPRESSIONS_FROM_MACROS,
- Allow,
+ Warn,
"trailing semicolon in macro body used as expression",
@future_incompatible = FutureIncompatibleInfo {
reference: "issue #79813 <https://github.com/rust-lang/rust/issues/79813>",
diff --git a/compiler/rustc_middle/src/traits/select.rs b/compiler/rustc_middle/src/traits/select.rs
index ab085175762ab..924568a01a7de 100644
--- a/compiler/rustc_middle/src/traits/select.rs
+++ b/compiler/rustc_middle/src/traits/select.rs
@@ -12,12 +12,12 @@ use rustc_hir::def_id::DefId;
use rustc_query_system::cache::Cache;
pub type SelectionCache<'tcx> = Cache<
- ty::ParamEnvAnd<'tcx, ty::TraitRef<'tcx>>,
+ ty::ConstnessAnd<ty::ParamEnvAnd<'tcx, ty::TraitRef<'tcx>>>,
SelectionResult<'tcx, SelectionCandidate<'tcx>>,
>;
pub type EvaluationCache<'tcx> =
- Cache<ty::ParamEnvAnd<'tcx, ty::PolyTraitRef<'tcx>>, EvaluationResult>;
+ Cache<ty::ParamEnvAnd<'tcx, ty::ConstnessAnd<ty::PolyTraitRef<'tcx>>>, EvaluationResult>;
/// The selection process begins by considering all impls, where
/// clauses, and so forth that might resolve an obligation. Sometimes
diff --git a/compiler/rustc_middle/src/ty/assoc.rs b/compiler/rustc_middle/src/ty/assoc.rs
index 2d177551664f6..5cb2b90fe1116 100644
--- a/compiler/rustc_middle/src/ty/assoc.rs
+++ b/compiler/rustc_middle/src/ty/assoc.rs
@@ -16,6 +16,13 @@ pub enum AssocItemContainer {
}
impl AssocItemContainer {
+ pub fn impl_def_id(&self) -> Option<DefId> {
+ match *self {
+ ImplContainer(id) => Some(id),
+ _ => None,
+ }
+ }
+
/// Asserts that this is the `DefId` of an associated item declared
/// in a trait, and returns the trait `DefId`.
pub fn assert_trait(&self) -> DefId {
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 4ce49032398bc..badf3eae301ca 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -2171,7 +2171,7 @@ impl<'tcx> TyCtxt<'tcx> {
let generic_predicates = self.super_predicates_of(trait_did);
for (predicate, _) in generic_predicates.predicates {
- if let ty::PredicateKind::Trait(data, _) = predicate.kind().skip_binder() {
+ if let ty::PredicateKind::Trait(data) = predicate.kind().skip_binder() {
if set.insert(data.def_id()) {
stack.push(data.def_id());
}
diff --git a/compiler/rustc_middle/src/ty/error.rs b/compiler/rustc_middle/src/ty/error.rs
index f1c7c1ea852a2..3846d9ffdbae5 100644
--- a/compiler/rustc_middle/src/ty/error.rs
+++ b/compiler/rustc_middle/src/ty/error.rs
@@ -33,6 +33,7 @@ impl<T> ExpectedFound<T> {
#[derive(Clone, Debug, TypeFoldable)]
pub enum TypeError<'tcx> {
Mismatch,
+ ConstnessMismatch(ExpectedFound<hir::Constness>),
UnsafetyMismatch(ExpectedFound<hir::Unsafety>),
AbiMismatch(ExpectedFound<abi::Abi>),
Mutability,
@@ -106,6 +107,9 @@ impl<'tcx> fmt::Display for TypeError<'tcx> {
CyclicTy(_) => write!(f, "cyclic type of infinite size"),
CyclicConst(_) => write!(f, "encountered a self-referencing constant"),
Mismatch => write!(f, "types differ"),
+ ConstnessMismatch(values) => {
+ write!(f, "expected {} fn, found {} fn", values.expected, values.found)
+ }
UnsafetyMismatch(values) => {
write!(f, "expected {} fn, found {} fn", values.expected, values.found)
}
@@ -213,9 +217,11 @@ impl<'tcx> TypeError<'tcx> {
pub fn must_include_note(&self) -> bool {
use self::TypeError::*;
match self {
- CyclicTy(_) | CyclicConst(_) | UnsafetyMismatch(_) | Mismatch | AbiMismatch(_)
- | FixedArraySize(_) | ArgumentSorts(..) | Sorts(_) | IntMismatch(_)
- | FloatMismatch(_) | VariadicMismatch(_) | TargetFeatureCast(_) => false,
+ CyclicTy(_) | CyclicConst(_) | UnsafetyMismatch(_) | ConstnessMismatch(_)
+ | Mismatch | AbiMismatch(_) | FixedArraySize(_) | ArgumentSorts(..) | Sorts(_)
+ | IntMismatch(_) | FloatMismatch(_) | VariadicMismatch(_) | TargetFeatureCast(_) => {
+ false
+ }
Mutability
| ArgumentMutability(_)
diff --git a/compiler/rustc_middle/src/ty/flags.rs b/compiler/rustc_middle/src/ty/flags.rs
index 9faa172a4973f..391c8292bd542 100644
--- a/compiler/rustc_middle/src/ty/flags.rs
+++ b/compiler/rustc_middle/src/ty/flags.rs
@@ -216,7 +216,7 @@ impl FlagComputation {
fn add_predicate_atom(&mut self, atom: ty::PredicateKind<'_>) {
match atom {
- ty::PredicateKind::Trait(trait_pred, _constness) => {
+ ty::PredicateKind::Trait(trait_pred) => {
self.add_substs(trait_pred.trait_ref.substs);
}
ty::PredicateKind::RegionOutlives(ty::OutlivesPredicate(a, b)) => {
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index a6aff42479069..6ea44789c7a38 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -456,7 +456,7 @@ pub enum PredicateKind<'tcx> {
/// A trait predicate will have `Constness::Const` if it originates
/// from a bound on a `const fn` without the `?const` opt-out (e.g.,
/// `const fn foobar<Foo: Bar>() {}`).
- Trait(TraitPredicate<'tcx>, Constness),
+ Trait(TraitPredicate<'tcx>),
/// `where 'a: 'b`
RegionOutlives(RegionOutlivesPredicate<'tcx>),
@@ -612,6 +612,11 @@ impl<'tcx> Predicate<'tcx> {
#[derive(HashStable, TypeFoldable)]
pub struct TraitPredicate<'tcx> {
pub trait_ref: TraitRef<'tcx>,
+
+ /// A trait predicate will have `Constness::Const` if it originates
+ /// from a bound on a `const fn` without the `?const` opt-out (e.g.,
+ /// `const fn foobar<Foo: Bar>() {}`).
+ pub constness: hir::Constness,
}
pub type PolyTraitPredicate<'tcx> = ty::Binder<'tcx, TraitPredicate<'tcx>>;
@@ -745,8 +750,11 @@ impl ToPredicate<'tcx> for PredicateKind<'tcx> {
impl<'tcx> ToPredicate<'tcx> for ConstnessAnd<TraitRef<'tcx>> {
fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
- PredicateKind::Trait(ty::TraitPredicate { trait_ref: self.value }, self.constness)
- .to_predicate(tcx)
+ PredicateKind::Trait(ty::TraitPredicate {
+ trait_ref: self.value,
+ constness: self.constness,
+ })
+ .to_predicate(tcx)
}
}
@@ -754,15 +762,15 @@ impl<'tcx> ToPredicate<'tcx> for ConstnessAnd<PolyTraitRef<'tcx>> {
fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
self.value
.map_bound(|trait_ref| {
- PredicateKind::Trait(ty::TraitPredicate { trait_ref }, self.constness)
+ PredicateKind::Trait(ty::TraitPredicate { trait_ref, constness: self.constness })
})
.to_predicate(tcx)
}
}
-impl<'tcx> ToPredicate<'tcx> for ConstnessAnd<PolyTraitPredicate<'tcx>> {
+impl<'tcx> ToPredicate<'tcx> for PolyTraitPredicate<'tcx> {
fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
- self.value.map_bound(|value| PredicateKind::Trait(value, self.constness)).to_predicate(tcx)
+ self.map_bound(PredicateKind::Trait).to_predicate(tcx)
}
}
@@ -788,8 +796,8 @@ impl<'tcx> Predicate<'tcx> {
pub fn to_opt_poly_trait_ref(self) -> Option<ConstnessAnd<PolyTraitRef<'tcx>>> {
let predicate = self.kind();
match predicate.skip_binder() {
- PredicateKind::Trait(t, constness) => {
- Some(ConstnessAnd { constness, value: predicate.rebind(t.trait_ref) })
+ PredicateKind::Trait(t) => {
+ Some(ConstnessAnd { constness: t.constness, value: predicate.rebind(t.trait_ref) })
}
PredicateKind::Projection(..)
| PredicateKind::Subtype(..)
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
index dc94124e62ab6..c96621338f574 100644
--- a/compiler/rustc_middle/src/ty/print/pretty.rs
+++ b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -630,7 +630,7 @@ pub trait PrettyPrinter<'tcx>:
for (predicate, _) in bounds {
let predicate = predicate.subst(self.tcx(), substs);
let bound_predicate = predicate.kind();
- if let ty::PredicateKind::Trait(pred, _) = bound_predicate.skip_binder() {
+ if let ty::PredicateKind::Trait(pred) = bound_predicate.skip_binder() {
let trait_ref = bound_predicate.rebind(pred.trait_ref);
// Don't print +Sized, but rather +?Sized if absent.
if Some(trait_ref.def_id()) == self.tcx().lang_items().sized_trait() {
@@ -2264,10 +2264,7 @@ define_print_and_forward_display! {
ty::PredicateKind<'tcx> {
match *self {
- ty::PredicateKind::Trait(ref data, constness) => {
- if let hir::Constness::Const = constness {
- p!("const ");
- }
+ ty::PredicateKind::Trait(ref data) => {
p!(print(data))
}
ty::PredicateKind::Subtype(predicate) => p!(print(predicate)),
diff --git a/compiler/rustc_middle/src/ty/relate.rs b/compiler/rustc_middle/src/ty/relate.rs
index a4c36be21992b..9c48f05617e09 100644
--- a/compiler/rustc_middle/src/ty/relate.rs
+++ b/compiler/rustc_middle/src/ty/relate.rs
@@ -200,6 +200,33 @@ impl<'tcx> Relate<'tcx> for ty::FnSig<'tcx> {
}
}
+impl<'tcx> Relate<'tcx> for ast::Constness {
+ fn relate<R: TypeRelation<'tcx>>(
+ relation: &mut R,
+ a: ast::Constness,
+ b: ast::Constness,
+ ) -> RelateResult<'tcx, ast::Constness> {
+ if a != b {
+ Err(TypeError::ConstnessMismatch(expected_found(relation, a, b)))
+ } else {
+ Ok(a)
+ }
+ }
+}
+
+impl<'tcx, T: Relate<'tcx>> Relate<'tcx> for ty::ConstnessAnd<T> {
+ fn relate<R: TypeRelation<'tcx>>(
+ relation: &mut R,
+ a: ty::ConstnessAnd<T>,
+ b: ty::ConstnessAnd<T>,
+ ) -> RelateResult<'tcx, ty::ConstnessAnd<T>> {
+ Ok(ty::ConstnessAnd {
+ constness: relation.relate(a.constness, b.constness)?,
+ value: relation.relate(a.value, b.value)?,
+ })
+ }
+}
+
impl<'tcx> Relate<'tcx> for ast::Unsafety {
fn relate<R: TypeRelation<'tcx>>(
relation: &mut R,
@@ -767,7 +794,10 @@ impl<'tcx> Relate<'tcx> for ty::TraitPredicate<'tcx> {
a: ty::TraitPredicate<'tcx>,
b: ty::TraitPredicate<'tcx>,
) -> RelateResult<'tcx, ty::TraitPredicate<'tcx>> {
- Ok(ty::TraitPredicate { trait_ref: relation.relate(a.trait_ref, b.trait_ref)? })
+ Ok(ty::TraitPredicate {
+ trait_ref: relation.relate(a.trait_ref, b.trait_ref)?,
+ constness: relation.relate(a.constness, b.constness)?,
+ })
}
}
diff --git a/compiler/rustc_middle/src/ty/structural_impls.rs b/compiler/rustc_middle/src/ty/structural_impls.rs
index 7290c41d615df..62397752db2fc 100644
--- a/compiler/rustc_middle/src/ty/structural_impls.rs
+++ b/compiler/rustc_middle/src/ty/structural_impls.rs
@@ -155,6 +155,9 @@ impl fmt::Debug for ty::ParamConst {
impl fmt::Debug for ty::TraitPredicate<'tcx> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ if let hir::Constness::Const = self.constness {
+ write!(f, "const ")?;
+ }
write!(f, "TraitPredicate({:?})", self.trait_ref)
}
}
@@ -174,12 +177,7 @@ impl fmt::Debug for ty::Predicate<'tcx> {
impl fmt::Debug for ty::PredicateKind<'tcx> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
- ty::PredicateKind::Trait(ref a, constness) => {
- if let hir::Constness::Const = constness {
- write!(f, "const ")?;
- }
- a.fmt(f)
- }
+ ty::PredicateKind::Trait(ref a) => a.fmt(f),
ty::PredicateKind::Subtype(ref pair) => pair.fmt(f),
ty::PredicateKind::RegionOutlives(ref pair) => pair.fmt(f),
ty::PredicateKind::TypeOutlives(ref pair) => pair.fmt(f),
@@ -366,7 +364,8 @@ impl<'a, 'tcx> Lift<'tcx> for ty::ExistentialPredicate<'a> {
impl<'a, 'tcx> Lift<'tcx> for ty::TraitPredicate<'a> {
type Lifted = ty::TraitPredicate<'tcx>;
fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<ty::TraitPredicate<'tcx>> {
- tcx.lift(self.trait_ref).map(|trait_ref| ty::TraitPredicate { trait_ref })
+ tcx.lift(self.trait_ref)
+ .map(|trait_ref| ty::TraitPredicate { trait_ref, constness: self.constness })
}
}
@@ -419,9 +418,7 @@ impl<'a, 'tcx> Lift<'tcx> for ty::PredicateKind<'a> {
type Lifted = ty::PredicateKind<'tcx>;
fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted> {
match self {
- ty::PredicateKind::Trait(data, constness) => {
- tcx.lift(data).map(|data| ty::PredicateKind::Trait(data, constness))
- }
+ ty::PredicateKind::Trait(data) => tcx.lift(data).map(ty::PredicateKind::Trait),
ty::PredicateKind::Subtype(data) => tcx.lift(data).map(ty::PredicateKind::Subtype),
ty::PredicateKind::RegionOutlives(data) => {
tcx.lift(data).map(ty::PredicateKind::RegionOutlives)
@@ -584,6 +581,7 @@ impl<'a, 'tcx> Lift<'tcx> for ty::error::TypeError<'a> {
Some(match self {
Mismatch => Mismatch,
+ ConstnessMismatch(x) => ConstnessMismatch(x),
UnsafetyMismatch(x) => UnsafetyMismatch(x),
AbiMismatch(x) => AbiMismatch(x),
Mutability => Mutability,
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
index 6a7e349819afd..a1edb8071c459 100644
--- a/compiler/rustc_middle/src/ty/sty.rs
+++ b/compiler/rustc_middle/src/ty/sty.rs
@@ -876,7 +876,10 @@ impl<'tcx> PolyTraitRef<'tcx> {
}
pub fn to_poly_trait_predicate(&self) -> ty::PolyTraitPredicate<'tcx> {
- self.map_bound(|trait_ref| ty::TraitPredicate { trait_ref })
+ self.map_bound(|trait_ref| ty::TraitPredicate {
+ trait_ref,
+ constness: hir::Constness::NotConst,
+ })
}
}
diff --git a/compiler/rustc_mir/src/borrow_check/region_infer/opaque_types.rs b/compiler/rustc_mir/src/borrow_check/region_infer/opaque_types.rs
index f2d69255d50ff..e9ab62e1664f9 100644
--- a/compiler/rustc_mir/src/borrow_check/region_infer/opaque_types.rs
+++ b/compiler/rustc_mir/src/borrow_check/region_infer/opaque_types.rs
@@ -83,6 +83,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
.and_then(|ur_vid| self.definitions[*ur_vid].external_name)
.unwrap_or(infcx.tcx.lifetimes.re_root_empty),
ty::ReLateBound(..) => region,
+ ty::ReStatic => region,
_ => {
infcx.tcx.sess.delay_span_bug(
span,
diff --git a/compiler/rustc_mir/src/borrow_check/type_check/mod.rs b/compiler/rustc_mir/src/borrow_check/type_check/mod.rs
index 3fb06cd2f5f44..3d9d0b358a42e 100644
--- a/compiler/rustc_mir/src/borrow_check/type_check/mod.rs
+++ b/compiler/rustc_mir/src/borrow_check/type_check/mod.rs
@@ -1085,11 +1085,12 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
span_mirbug!(
self,
user_annotation,
- "bad user type AscribeUserType({:?}, {:?} {:?}): {:?}",
+ "bad user type AscribeUserType({:?}, {:?} {:?}, type_of={:?}): {:?}",
inferred_ty,
def_id,
user_substs,
- terr
+ self.tcx().type_of(def_id),
+ terr,
);
}
}
@@ -2704,10 +2705,10 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
category: ConstraintCategory,
) {
self.prove_predicates(
- Some(ty::PredicateKind::Trait(
- ty::TraitPredicate { trait_ref },
- hir::Constness::NotConst,
- )),
+ Some(ty::PredicateKind::Trait(ty::TraitPredicate {
+ trait_ref,
+ constness: hir::Constness::NotConst,
+ })),
locations,
category,
);
diff --git a/compiler/rustc_mir/src/transform/check_consts/check.rs b/compiler/rustc_mir/src/transform/check_consts/check.rs
index 109da59aa4380..48fd63b258ca7 100644
--- a/compiler/rustc_mir/src/transform/check_consts/check.rs
+++ b/compiler/rustc_mir/src/transform/check_consts/check.rs
@@ -423,7 +423,7 @@ impl Checker<'mir, 'tcx> {
ty::PredicateKind::Subtype(_) => {
bug!("subtype predicate on function: {:#?}", predicate)
}
- ty::PredicateKind::Trait(pred, _constness) => {
+ ty::PredicateKind::Trait(pred) => {
if Some(pred.def_id()) == tcx.lang_items().sized_trait() {
continue;
}
@@ -817,7 +817,10 @@ impl Visitor<'tcx> for Checker<'mir, 'tcx> {
let obligation = Obligation::new(
ObligationCause::dummy(),
param_env,
- Binder::dummy(TraitPredicate { trait_ref }),
+ Binder::dummy(TraitPredicate {
+ trait_ref,
+ constness: hir::Constness::Const,
+ }),
);
let implsrc = tcx.infer_ctxt().enter(|infcx| {
diff --git a/compiler/rustc_mir/src/transform/function_item_references.rs b/compiler/rustc_mir/src/transform/function_item_references.rs
index 8d02ac6d9b774..26fe796cb916f 100644
--- a/compiler/rustc_mir/src/transform/function_item_references.rs
+++ b/compiler/rustc_mir/src/transform/function_item_references.rs
@@ -132,7 +132,7 @@ impl<'a, 'tcx> FunctionItemRefChecker<'a, 'tcx> {
/// If the given predicate is the trait `fmt::Pointer`, returns the bound parameter type.
fn is_pointer_trait(&self, bound: &PredicateKind<'tcx>) -> Option<Ty<'tcx>> {
- if let ty::PredicateKind::Trait(predicate, _) = bound {
+ if let ty::PredicateKind::Trait(predicate) = bound {
if self.tcx.is_diagnostic_item(sym::pointer_trait, predicate.def_id()) {
Some(predicate.trait_ref.self_ty())
} else {
diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs
index cd91ecdf2bad3..a0792aac681b3 100644
--- a/compiler/rustc_privacy/src/lib.rs
+++ b/compiler/rustc_privacy/src/lib.rs
@@ -122,7 +122,7 @@ where
fn visit_predicate(&mut self, predicate: ty::Predicate<'tcx>) -> ControlFlow<V::BreakTy> {
match predicate.kind().skip_binder() {
- ty::PredicateKind::Trait(ty::TraitPredicate { trait_ref }, _) => {
+ ty::PredicateKind::Trait(ty::TraitPredicate { trait_ref, constness: _ }) => {
self.visit_trait(trait_ref)
}
ty::PredicateKind::Projection(ty::ProjectionPredicate { projection_ty, ty }) => {
diff --git a/compiler/rustc_resolve/src/late/lifetimes.rs b/compiler/rustc_resolve/src/late/lifetimes.rs
index e18dae0b8eebb..d79fd910b7e78 100644
--- a/compiler/rustc_resolve/src/late/lifetimes.rs
+++ b/compiler/rustc_resolve/src/late/lifetimes.rs
@@ -2657,7 +2657,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
let obligations = predicates.predicates.iter().filter_map(|&(pred, _)| {
let bound_predicate = pred.kind();
match bound_predicate.skip_binder() {
- ty::PredicateKind::Trait(data, _) => {
+ ty::PredicateKind::Trait(data) => {
// The order here needs to match what we would get from `subst_supertrait`
let pred_bound_vars = bound_predicate.bound_vars();
let mut all_bound_vars = bound_vars.clone();
diff --git a/compiler/rustc_trait_selection/src/traits/auto_trait.rs b/compiler/rustc_trait_selection/src/traits/auto_trait.rs
index f54eb0914a5a7..282502cfa0d3d 100644
--- a/compiler/rustc_trait_selection/src/traits/auto_trait.rs
+++ b/compiler/rustc_trait_selection/src/traits/auto_trait.rs
@@ -285,6 +285,7 @@ impl AutoTraitFinder<'tcx> {
def_id: trait_did,
substs: infcx.tcx.mk_substs_trait(ty, &[]),
},
+ constness: hir::Constness::NotConst,
}));
let computed_preds = param_env.caller_bounds().iter();
@@ -344,10 +345,7 @@ impl AutoTraitFinder<'tcx> {
Err(SelectionError::Unimplemented) => {
if self.is_param_no_infer(pred.skip_binder().trait_ref.substs) {
already_visited.remove(&pred);
- self.add_user_pred(
- &mut user_computed_preds,
- pred.without_const().to_predicate(self.tcx),
- );
+ self.add_user_pred(&mut user_computed_preds, pred.to_predicate(self.tcx));
predicates.push_back(pred);
} else {
debug!(
@@ -414,10 +412,8 @@ impl AutoTraitFinder<'tcx> {
) {
let mut should_add_new = true;
user_computed_preds.retain(|&old_pred| {
- if let (
- ty::PredicateKind::Trait(new_trait, _),
- ty::PredicateKind::Trait(old_trait, _),
- ) = (new_pred.kind().skip_binder(), old_pred.kind().skip_binder())
+ if let (ty::PredicateKind::Trait(new_trait), ty::PredicateKind::Trait(old_trait)) =
+ (new_pred.kind().skip_binder(), old_pred.kind().skip_binder())
{
if new_trait.def_id() == old_trait.def_id() {
let new_substs = new_trait.trait_ref.substs;
@@ -638,7 +634,7 @@ impl AutoTraitFinder<'tcx> {
let bound_predicate = predicate.kind();
match bound_predicate.skip_binder() {
- ty::PredicateKind::Trait(p, _) => {
+ ty::PredicateKind::Trait(p) => {
// Add this to `predicates` so that we end up calling `select`
// with it. If this predicate ends up being unimplemented,
// then `evaluate_predicates` will handle adding it the `ParamEnv`
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
index c134af44992de..665f64045dee1 100644
--- a/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
@@ -276,7 +276,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
let bound_predicate = obligation.predicate.kind();
match bound_predicate.skip_binder() {
- ty::PredicateKind::Trait(trait_predicate, _) => {
+ ty::PredicateKind::Trait(trait_predicate) => {
let trait_predicate = bound_predicate.rebind(trait_predicate);
let trait_predicate = self.resolve_vars_if_possible(trait_predicate);
@@ -517,8 +517,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
);
trait_pred
});
- let unit_obligation =
- obligation.with(predicate.without_const().to_predicate(tcx));
+ let unit_obligation = obligation.with(predicate.to_predicate(tcx));
if self.predicate_may_hold(&unit_obligation) {
err.note("this trait is implemented for `()`.");
err.note(
@@ -1147,7 +1146,7 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> {
// FIXME: It should be possible to deal with `ForAll` in a cleaner way.
let bound_error = error.kind();
let (cond, error) = match (cond.kind().skip_binder(), bound_error.skip_binder()) {
- (ty::PredicateKind::Trait(..), ty::PredicateKind::Trait(error, _)) => {
+ (ty::PredicateKind::Trait(..), ty::PredicateKind::Trait(error)) => {
(cond, bound_error.rebind(error))
}
_ => {
@@ -1158,7 +1157,7 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> {
for obligation in super::elaborate_predicates(self.tcx, std::iter::once(cond)) {
let bound_predicate = obligation.predicate.kind();
- if let ty::PredicateKind::Trait(implication, _) = bound_predicate.skip_binder() {
+ if let ty::PredicateKind::Trait(implication) = bound_predicate.skip_binder() {
let error = error.to_poly_trait_ref();
let implication = bound_predicate.rebind(implication.trait_ref);
// FIXME: I'm just not taking associated types at all here.
@@ -1535,7 +1534,7 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> {
let bound_predicate = predicate.kind();
let mut err = match bound_predicate.skip_binder() {
- ty::PredicateKind::Trait(data, _) => {
+ ty::PredicateKind::Trait(data) => {
let trait_ref = bound_predicate.rebind(data.trait_ref);
debug!("trait_ref {:?}", trait_ref);
@@ -1800,7 +1799,7 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> {
match (obligation.predicate.kind().skip_binder(), obligation.cause.code.peel_derives())
{
(
- ty::PredicateKind::Trait(pred, _),
+ ty::PredicateKind::Trait(pred),
&ObligationCauseCode::BindingObligation(item_def_id, span),
) => (pred, item_def_id, span),
_ => return,
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
index 9a33875d6e493..5fab9d487e23a 100644
--- a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
+++ b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
@@ -1387,7 +1387,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
// bound was introduced. At least one generator should be present for this diagnostic to be
// modified.
let (mut trait_ref, mut target_ty) = match obligation.predicate.kind().skip_binder() {
- ty::PredicateKind::Trait(p, _) => (Some(p.trait_ref), Some(p.self_ty())),
+ ty::PredicateKind::Trait(p) => (Some(p.trait_ref), Some(p.self_ty())),
_ => (None, None),
};
let mut generator = None;
diff --git a/compiler/rustc_trait_selection/src/traits/fulfill.rs b/compiler/rustc_trait_selection/src/traits/fulfill.rs
index 9ec1dd5c2ee3b..7048f0dbedcb6 100644
--- a/compiler/rustc_trait_selection/src/traits/fulfill.rs
+++ b/compiler/rustc_trait_selection/src/traits/fulfill.rs
@@ -3,6 +3,7 @@ use rustc_data_structures::obligation_forest::ProcessResult;
use rustc_data_structures::obligation_forest::{Error, ForestObligation, Outcome};
use rustc_data_structures::obligation_forest::{ObligationForest, ObligationProcessor};
use rustc_errors::ErrorReported;
+use rustc_hir as hir;
use rustc_infer::traits::{SelectionError, TraitEngine, TraitEngineExt as _, TraitObligation};
use rustc_middle::mir::abstract_const::NotConstEvaluatable;
use rustc_middle::mir::interpret::ErrorHandled;
@@ -228,6 +229,22 @@ impl<'tcx> TraitEngine<'tcx> for FulfillmentContext<'tcx> {
if errors.is_empty() { Ok(()) } else { Err(errors) }
}
+ fn select_all_with_constness_or_error(
+ &mut self,
+ infcx: &InferCtxt<'_, 'tcx>,
+ constness: rustc_hir::Constness,
+ ) -> Result<(), Vec<FulfillmentError<'tcx>>> {
+ self.select_with_constness_where_possible(infcx, constness)?;
+
+ let errors: Vec<_> = self
+ .predicates
+ .to_errors(CodeAmbiguity)
+ .into_iter()
+ .map(to_fulfillment_error)
+ .collect();
+ if errors.is_empty() { Ok(()) } else { Err(errors) }
+ }
+
fn select_where_possible(
&mut self,
infcx: &InferCtxt<'_, 'tcx>,
@@ -236,6 +253,15 @@ impl<'tcx> TraitEngine<'tcx> for FulfillmentContext<'tcx> {
self.select(&mut selcx)
}
+ fn select_with_constness_where_possible(
+ &mut self,
+ infcx: &InferCtxt<'_, 'tcx>,
+ constness: hir::Constness,
+ ) -> Result<(), Vec<FulfillmentError<'tcx>>> {
+ let mut selcx = SelectionContext::with_constness(infcx, constness);
+ self.select(&mut selcx)
+ }
+
fn pending_obligations(&self) -> Vec<PredicateObligation<'tcx>> {
self.predicates.map_pending_obligations(|o| o.obligation.clone())
}
@@ -352,7 +378,7 @@ impl<'a, 'b, 'tcx> FulfillProcessor<'a, 'b, 'tcx> {
// Evaluation will discard candidates using the leak check.
// This means we need to pass it the bound version of our
// predicate.
- ty::PredicateKind::Trait(trait_ref, _constness) => {
+ ty::PredicateKind::Trait(trait_ref) => {
let trait_obligation = obligation.with(binder.rebind(trait_ref));
self.process_trait_obligation(
@@ -388,7 +414,7 @@ impl<'a, 'b, 'tcx> FulfillProcessor<'a, 'b, 'tcx> {
}
},
Some(pred) => match pred {
- ty::PredicateKind::Trait(data, _) => {
+ ty::PredicateKind::Trait(data) => {
let trait_obligation = obligation.with(Binder::dummy(data));
self.process_trait_obligation(
@@ -623,7 +649,12 @@ impl<'a, 'b, 'tcx> FulfillProcessor<'a, 'b, 'tcx> {
if obligation.predicate.is_global() {
// no type variables present, can use evaluation for better caching.
// FIXME: consider caching errors too.
- if infcx.predicate_must_hold_considering_regions(obligation) {
+ //
+ // If the predicate is considered const, then we cannot use this because
+ // it will cause false negatives in the ui tests.
+ if !self.selcx.is_predicate_const(obligation.predicate)
+ && infcx.predicate_must_hold_considering_regions(obligation)
+ {
debug!(
"selecting trait at depth {} evaluated to holds",
obligation.recursion_depth
@@ -677,7 +708,12 @@ impl<'a, 'b, 'tcx> FulfillProcessor<'a, 'b, 'tcx> {
if obligation.predicate.is_global() {
// no type variables present, can use evaluation for better caching.
// FIXME: consider caching errors too.
- if self.selcx.infcx().predicate_must_hold_considering_regions(obligation) {
+ //
+ // If the predicate is considered const, then we cannot use this because
+ // it will cause false negatives in the ui tests.
+ if !self.selcx.is_predicate_const(obligation.predicate)
+ && self.selcx.infcx().predicate_must_hold_considering_regions(obligation)
+ {
return ProcessResult::Changed(vec![]);
} else {
tracing::debug!("Does NOT hold: {:?}", obligation);
diff --git a/compiler/rustc_trait_selection/src/traits/object_safety.rs b/compiler/rustc_trait_selection/src/traits/object_safety.rs
index 7ebef7f8883ae..04bc689d51161 100644
--- a/compiler/rustc_trait_selection/src/traits/object_safety.rs
+++ b/compiler/rustc_trait_selection/src/traits/object_safety.rs
@@ -280,7 +280,7 @@ fn predicate_references_self(
let self_ty = tcx.types.self_param;
let has_self_ty = |arg: &GenericArg<'_>| arg.walk().any(|arg| arg == self_ty.into());
match predicate.kind().skip_binder() {
- ty::PredicateKind::Trait(ref data, _) => {
+ ty::PredicateKind::Trait(ref data) => {
// In the case of a trait predicate, we can skip the "self" type.
if data.trait_ref.substs[1..].iter().any(has_self_ty) { Some(sp) } else { None }
}
@@ -331,7 +331,7 @@ fn generics_require_sized_self(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
let predicates = predicates.instantiate_identity(tcx).predicates;
elaborate_predicates(tcx, predicates.into_iter()).any(|obligation| {
match obligation.predicate.kind().skip_binder() {
- ty::PredicateKind::Trait(ref trait_pred, _) => {
+ ty::PredicateKind::Trait(ref trait_pred) => {
trait_pred.def_id() == sized_def_id && trait_pred.self_ty().is_param(0)
}
ty::PredicateKind::Projection(..)
diff --git a/compiler/rustc_trait_selection/src/traits/query/type_op/prove_predicate.rs b/compiler/rustc_trait_selection/src/traits/query/type_op/prove_predicate.rs
index de538c62c5e39..02e9b4d0f0e72 100644
--- a/compiler/rustc_trait_selection/src/traits/query/type_op/prove_predicate.rs
+++ b/compiler/rustc_trait_selection/src/traits/query/type_op/prove_predicate.rs
@@ -15,7 +15,7 @@ impl<'tcx> super::QueryTypeOp<'tcx> for ProvePredicate<'tcx> {
// `&T`, accounts for about 60% percentage of the predicates
// we have to prove. No need to canonicalize and all that for
// such cases.
- if let ty::PredicateKind::Trait(trait_ref, _) = key.value.predicate.kind().skip_binder() {
+ if let ty::PredicateKind::Trait(trait_ref) = key.value.predicate.kind().skip_binder() {
if let Some(sized_def_id) = tcx.lang_items().sized_trait() {
if trait_ref.def_id() == sized_def_id {
if trait_ref.self_ty().is_trivially_sized(tcx) {
diff --git a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
index 752f6a8debc9e..ddad2c430050e 100644
--- a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
@@ -144,7 +144,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
// Instead, we select the right impl now but report "`Bar` does
// not implement `Clone`".
if candidates.len() == 1 {
- return self.filter_negative_and_reservation_impls(candidates.pop().unwrap());
+ return self.filter_impls(candidates.pop().unwrap(), stack.obligation);
}
// Winnow, but record the exact outcome of evaluation, which
@@ -217,7 +217,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
}
// Just one candidate left.
- self.filter_negative_and_reservation_impls(candidates.pop().unwrap().candidate)
+ self.filter_impls(candidates.pop().unwrap().candidate, stack.obligation)
}
pub(super) fn assemble_candidates<'o>(
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
index 95611ebc8188c..dcf5ac63b78ea 100644
--- a/compiler/rustc_trait_selection/src/traits/select/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -41,8 +41,9 @@ use rustc_middle::ty::fast_reject;
use rustc_middle::ty::print::with_no_trimmed_paths;
use rustc_middle::ty::relate::TypeRelation;
use rustc_middle::ty::subst::{GenericArgKind, Subst, SubstsRef};
+use rustc_middle::ty::WithConstness;
use rustc_middle::ty::{self, PolyProjectionPredicate, ToPolyTraitRef, ToPredicate};
-use rustc_middle::ty::{Ty, TyCtxt, TypeFoldable, WithConstness};
+use rustc_middle::ty::{Ty, TyCtxt, TypeFoldable};
use rustc_span::symbol::sym;
use std::cell::{Cell, RefCell};
@@ -129,6 +130,9 @@ pub struct SelectionContext<'cx, 'tcx> {
/// and a negative impl
allow_negative_impls: bool,
+ /// Do we only want const impls when we have a const trait predicate?
+ const_impls_required: bool,
+
/// The mode that trait queries run in, which informs our error handling
/// policy. In essence, canonicalized queries need their errors propagated
/// rather than immediately reported because we do not have accurate spans.
@@ -141,7 +145,7 @@ struct TraitObligationStack<'prev, 'tcx> {
/// The trait ref from `obligation` but "freshened" with the
/// selection-context's freshener. Used to check for recursion.
- fresh_trait_ref: ty::PolyTraitRef<'tcx>,
+ fresh_trait_ref: ty::ConstnessAnd<ty::PolyTraitRef<'tcx>>,
/// Starts out equal to `depth` -- if, during evaluation, we
/// encounter a cycle, then we will set this flag to the minimum
@@ -220,6 +224,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
intercrate: false,
intercrate_ambiguity_causes: None,
allow_negative_impls: false,
+ const_impls_required: false,
query_mode: TraitQueryMode::Standard,
}
}
@@ -231,6 +236,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
intercrate: true,
intercrate_ambiguity_causes: None,
allow_negative_impls: false,
+ const_impls_required: false,
query_mode: TraitQueryMode::Standard,
}
}
@@ -246,6 +252,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
intercrate: false,
intercrate_ambiguity_causes: None,
allow_negative_impls,
+ const_impls_required: false,
query_mode: TraitQueryMode::Standard,
}
}
@@ -261,10 +268,26 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
intercrate: false,
intercrate_ambiguity_causes: None,
allow_negative_impls: false,
+ const_impls_required: false,
query_mode,
}
}
+ pub fn with_constness(
+ infcx: &'cx InferCtxt<'cx, 'tcx>,
+ constness: hir::Constness,
+ ) -> SelectionContext<'cx, 'tcx> {
+ SelectionContext {
+ infcx,
+ freshener: infcx.freshener_keep_static(),
+ intercrate: false,
+ intercrate_ambiguity_causes: None,
+ allow_negative_impls: false,
+ const_impls_required: matches!(constness, hir::Constness::Const),
+ query_mode: TraitQueryMode::Standard,
+ }
+ }
+
/// Enables tracking of intercrate ambiguity causes. These are
/// used in coherence to give improved diagnostics. We don't do
/// this until we detect a coherence error because it can lead to
@@ -293,6 +316,18 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
self.infcx.tcx
}
+ /// returns `true` if the predicate is considered `const` to
+ /// this selection context.
+ pub fn is_predicate_const(&self, pred: ty::Predicate<'_>) -> bool {
+ match pred.kind().skip_binder() {
+ ty::PredicateKind::Trait(ty::TraitPredicate {
+ constness: hir::Constness::Const,
+ ..
+ }) if self.const_impls_required => true,
+ _ => false,
+ }
+ }
+
///////////////////////////////////////////////////////////////////////////
// Selection
//
@@ -454,7 +489,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
let result = ensure_sufficient_stack(|| {
let bound_predicate = obligation.predicate.kind();
match bound_predicate.skip_binder() {
- ty::PredicateKind::Trait(t, _) => {
+ ty::PredicateKind::Trait(t) => {
let t = bound_predicate.rebind(t);
debug_assert!(!t.has_escaping_bound_vars());
let obligation = obligation.with(t);
@@ -762,8 +797,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
// if the regions match exactly.
let cycle = stack.iter().skip(1).take_while(|s| s.depth >= cycle_depth);
let tcx = self.tcx();
- let cycle =
- cycle.map(|stack| stack.obligation.predicate.without_const().to_predicate(tcx));
+ let cycle = cycle.map(|stack| stack.obligation.predicate.to_predicate(tcx));
if self.coinductive_match(cycle) {
debug!("evaluate_stack --> recursive, coinductive");
Some(EvaluatedToOk)
@@ -805,7 +839,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
// terms of `Fn` etc, but we could probably make this more
// precise still.
let unbound_input_types =
- stack.fresh_trait_ref.skip_binder().substs.types().any(|ty| ty.is_fresh());
+ stack.fresh_trait_ref.value.skip_binder().substs.types().any(|ty| ty.is_fresh());
// This check was an imperfect workaround for a bug in the old
// intercrate mode; it should be removed when that goes away.
if unbound_input_types && self.intercrate {
@@ -873,7 +907,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
fn coinductive_predicate(&self, predicate: ty::Predicate<'tcx>) -> bool {
let result = match predicate.kind().skip_binder() {
- ty::PredicateKind::Trait(ref data, _) => self.tcx().trait_is_auto(data.def_id()),
+ ty::PredicateKind::Trait(ref data) => self.tcx().trait_is_auto(data.def_id()),
_ => false,
};
debug!(?predicate, ?result, "coinductive_predicate");
@@ -926,7 +960,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
fn check_evaluation_cache(
&self,
param_env: ty::ParamEnv<'tcx>,
- trait_ref: ty::PolyTraitRef<'tcx>,
+ trait_ref: ty::ConstnessAnd<ty::PolyTraitRef<'tcx>>,
) -> Option<EvaluationResult> {
let tcx = self.tcx();
if self.can_use_global_caches(param_env) {
@@ -940,7 +974,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
fn insert_evaluation_cache(
&mut self,
param_env: ty::ParamEnv<'tcx>,
- trait_ref: ty::PolyTraitRef<'tcx>,
+ trait_ref: ty::ConstnessAnd<ty::PolyTraitRef<'tcx>>,
dep_node: DepNodeIndex,
result: EvaluationResult,
) {
@@ -1016,13 +1050,44 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
(result, dep_node)
}
- // Treat negative impls as unimplemented, and reservation impls as ambiguity.
- fn filter_negative_and_reservation_impls(
+ #[instrument(level = "debug", skip(self))]
+ fn filter_impls(
&mut self,
candidate: SelectionCandidate<'tcx>,
+ obligation: &TraitObligation<'tcx>,
) -> SelectionResult<'tcx, SelectionCandidate<'tcx>> {
+ let tcx = self.tcx();
+ // Respect const trait obligations
+ if self.const_impls_required {
+ if let hir::Constness::Const = obligation.predicate.skip_binder().constness {
+ if Some(obligation.predicate.skip_binder().trait_ref.def_id)
+ != tcx.lang_items().sized_trait()
+ // const Sized bounds are skipped
+ {
+ match candidate {
+ // const impl
+ ImplCandidate(def_id)
+ if tcx.impl_constness(def_id) == hir::Constness::Const => {}
+ // const param
+ ParamCandidate(ty::ConstnessAnd {
+ constness: hir::Constness::Const,
+ ..
+ }) => {}
+ // auto trait impl
+ AutoImplCandidate(..) => {}
+ // generator, this will raise error in other places
+ // or ignore error with const_async_blocks feature
+ GeneratorCandidate => {}
+ _ => {
+ // reject all other types of candidates
+ return Err(Unimplemented);
+ }
+ }
+ }
+ }
+ }
+ // Treat negative impls as unimplemented, and reservation impls as ambiguity.
if let ImplCandidate(def_id) = candidate {
- let tcx = self.tcx();
match tcx.impl_polarity(def_id) {
ty::ImplPolarity::Negative if !self.allow_negative_impls => {
return Err(Unimplemented);
@@ -1036,7 +1101,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
let value = attr.and_then(|a| a.value_str());
if let Some(value) = value {
debug!(
- "filter_negative_and_reservation_impls: \
+ "filter_impls: \
reservation impl ambiguity on {:?}",
def_id
);
@@ -1103,13 +1168,19 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
cache_fresh_trait_pred: ty::PolyTraitPredicate<'tcx>,
) -> Option<SelectionResult<'tcx, SelectionCandidate<'tcx>>> {
let tcx = self.tcx();
- let trait_ref = &cache_fresh_trait_pred.skip_binder().trait_ref;
+ let pred = &cache_fresh_trait_pred.skip_binder();
+ let trait_ref = pred.trait_ref;
if self.can_use_global_caches(param_env) {
- if let Some(res) = tcx.selection_cache.get(¶m_env.and(*trait_ref), tcx) {
+ if let Some(res) = tcx
+ .selection_cache
+ .get(¶m_env.and(trait_ref).with_constness(pred.constness), tcx)
+ {
return Some(res);
}
}
- self.infcx.selection_cache.get(¶m_env.and(*trait_ref), tcx)
+ self.infcx
+ .selection_cache
+ .get(¶m_env.and(trait_ref).with_constness(pred.constness), tcx)
}
/// Determines whether can we safely cache the result
@@ -1146,7 +1217,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
candidate: SelectionResult<'tcx, SelectionCandidate<'tcx>>,
) {
let tcx = self.tcx();
- let trait_ref = cache_fresh_trait_pred.skip_binder().trait_ref;
+ let pred = cache_fresh_trait_pred.skip_binder();
+ let trait_ref = pred.trait_ref;
if !self.can_cache_candidate(&candidate) {
debug!(?trait_ref, ?candidate, "insert_candidate_cache - candidate is not cacheable");
@@ -1160,14 +1232,22 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
if !candidate.needs_infer() {
debug!(?trait_ref, ?candidate, "insert_candidate_cache global");
// This may overwrite the cache with the same value.
- tcx.selection_cache.insert(param_env.and(trait_ref), dep_node, candidate);
+ tcx.selection_cache.insert(
+ param_env.and(trait_ref).with_constness(pred.constness),
+ dep_node,
+ candidate,
+ );
return;
}
}
}
debug!(?trait_ref, ?candidate, "insert_candidate_cache local");
- self.infcx.selection_cache.insert(param_env.and(trait_ref), dep_node, candidate);
+ self.infcx.selection_cache.insert(
+ param_env.and(trait_ref).with_constness(pred.constness),
+ dep_node,
+ candidate,
+ );
}
/// Matches a predicate against the bounds of its self type.
@@ -1213,7 +1293,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
.enumerate()
.filter_map(|(idx, bound)| {
let bound_predicate = bound.kind();
- if let ty::PredicateKind::Trait(pred, _) = bound_predicate.skip_binder() {
+ if let ty::PredicateKind::Trait(pred) = bound_predicate.skip_binder() {
let bound = bound_predicate.rebind(pred.trait_ref);
if self.infcx.probe(|_| {
match self.match_normalize_trait_ref(
@@ -1997,8 +2077,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
fn match_fresh_trait_refs(
&self,
- previous: ty::PolyTraitRef<'tcx>,
- current: ty::PolyTraitRef<'tcx>,
+ previous: ty::ConstnessAnd<ty::PolyTraitRef<'tcx>>,
+ current: ty::ConstnessAnd<ty::PolyTraitRef<'tcx>>,
param_env: ty::ParamEnv<'tcx>,
) -> bool {
let mut matcher = ty::_match::Match::new(self.tcx(), param_env);
@@ -2010,8 +2090,11 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
previous_stack: TraitObligationStackList<'o, 'tcx>,
obligation: &'o TraitObligation<'tcx>,
) -> TraitObligationStack<'o, 'tcx> {
- let fresh_trait_ref =
- obligation.predicate.to_poly_trait_ref().fold_with(&mut self.freshener);
+ let fresh_trait_ref = obligation
+ .predicate
+ .to_poly_trait_ref()
+ .fold_with(&mut self.freshener)
+ .with_constness(obligation.predicate.skip_binder().constness);
let dfn = previous_stack.cache.next_dfn();
let depth = previous_stack.depth() + 1;
@@ -2290,7 +2373,7 @@ struct ProvisionalEvaluationCache<'tcx> {
/// - then we determine that `E` is in error -- we will then clear
/// all cache values whose DFN is >= 4 -- in this case, that
/// means the cached value for `F`.
- map: RefCell<FxHashMap<ty::PolyTraitRef<'tcx>, ProvisionalEvaluation>>,
+ map: RefCell<FxHashMap<ty::ConstnessAnd<ty::PolyTraitRef<'tcx>>, ProvisionalEvaluation>>,
}
/// A cache value for the provisional cache: contains the depth-first
@@ -2322,7 +2405,7 @@ impl<'tcx> ProvisionalEvaluationCache<'tcx> {
/// `reached_depth` (from the returned value).
fn get_provisional(
&self,
- fresh_trait_ref: ty::PolyTraitRef<'tcx>,
+ fresh_trait_ref: ty::ConstnessAnd<ty::PolyTraitRef<'tcx>>,
) -> Option<ProvisionalEvaluation> {
debug!(
?fresh_trait_ref,
@@ -2340,7 +2423,7 @@ impl<'tcx> ProvisionalEvaluationCache<'tcx> {
&self,
from_dfn: usize,
reached_depth: usize,
- fresh_trait_ref: ty::PolyTraitRef<'tcx>,
+ fresh_trait_ref: ty::ConstnessAnd<ty::PolyTraitRef<'tcx>>,
result: EvaluationResult,
) {
debug!(?from_dfn, ?fresh_trait_ref, ?result, "insert_provisional");
@@ -2418,7 +2501,7 @@ impl<'tcx> ProvisionalEvaluationCache<'tcx> {
fn on_completion(
&self,
dfn: usize,
- mut op: impl FnMut(ty::PolyTraitRef<'tcx>, EvaluationResult),
+ mut op: impl FnMut(ty::ConstnessAnd<ty::PolyTraitRef<'tcx>>, EvaluationResult),
) {
debug!(?dfn, "on_completion");
diff --git a/compiler/rustc_trait_selection/src/traits/wf.rs b/compiler/rustc_trait_selection/src/traits/wf.rs
index 27c8e00c5596c..9c9664d7b5e84 100644
--- a/compiler/rustc_trait_selection/src/traits/wf.rs
+++ b/compiler/rustc_trait_selection/src/traits/wf.rs
@@ -108,7 +108,7 @@ pub fn predicate_obligations<'a, 'tcx>(
// It's ok to skip the binder here because wf code is prepared for it
match predicate.kind().skip_binder() {
- ty::PredicateKind::Trait(t, _) => {
+ ty::PredicateKind::Trait(t) => {
wf.compute_trait_ref(&t.trait_ref, Elaborate::None);
}
ty::PredicateKind::RegionOutlives(..) => {}
@@ -226,7 +226,7 @@ fn extend_cause_with_original_assoc_item_obligation<'tcx>(
}
}
}
- ty::PredicateKind::Trait(pred, _) => {
+ ty::PredicateKind::Trait(pred) => {
// An associated item obligation born out of the `trait` failed to be met. An example
// can be seen in `ui/associated-types/point-at-type-on-obligation-failure-2.rs`.
debug!("extended_cause_with_original_assoc_item_obligation trait proj {:?}", pred);
diff --git a/compiler/rustc_traits/src/chalk/lowering.rs b/compiler/rustc_traits/src/chalk/lowering.rs
index a838172d664c3..974755e9e2669 100644
--- a/compiler/rustc_traits/src/chalk/lowering.rs
+++ b/compiler/rustc_traits/src/chalk/lowering.rs
@@ -87,7 +87,7 @@ impl<'tcx> LowerInto<'tcx, chalk_ir::InEnvironment<chalk_ir::Goal<RustInterner<'
ty::PredicateKind::TypeWellFormedFromEnv(ty) => {
chalk_ir::DomainGoal::FromEnv(chalk_ir::FromEnv::Ty(ty.lower_into(interner)))
}
- ty::PredicateKind::Trait(predicate, _) => chalk_ir::DomainGoal::FromEnv(
+ ty::PredicateKind::Trait(predicate) => chalk_ir::DomainGoal::FromEnv(
chalk_ir::FromEnv::Trait(predicate.trait_ref.lower_into(interner)),
),
ty::PredicateKind::RegionOutlives(predicate) => chalk_ir::DomainGoal::Holds(
@@ -137,7 +137,7 @@ impl<'tcx> LowerInto<'tcx, chalk_ir::GoalData<RustInterner<'tcx>>> for ty::Predi
collect_bound_vars(interner, interner.tcx, self.kind());
let value = match predicate {
- ty::PredicateKind::Trait(predicate, _) => {
+ ty::PredicateKind::Trait(predicate) => {
chalk_ir::GoalData::DomainGoal(chalk_ir::DomainGoal::Holds(
chalk_ir::WhereClause::Implemented(predicate.trait_ref.lower_into(interner)),
))
@@ -569,7 +569,7 @@ impl<'tcx> LowerInto<'tcx, Option<chalk_ir::QuantifiedWhereClause<RustInterner<'
let (predicate, binders, _named_regions) =
collect_bound_vars(interner, interner.tcx, self.kind());
let value = match predicate {
- ty::PredicateKind::Trait(predicate, _) => {
+ ty::PredicateKind::Trait(predicate) => {
Some(chalk_ir::WhereClause::Implemented(predicate.trait_ref.lower_into(interner)))
}
ty::PredicateKind::RegionOutlives(predicate) => {
@@ -702,7 +702,7 @@ impl<'tcx> LowerInto<'tcx, Option<chalk_solve::rust_ir::QuantifiedInlineBound<Ru
let (predicate, binders, _named_regions) =
collect_bound_vars(interner, interner.tcx, self.kind());
match predicate {
- ty::PredicateKind::Trait(predicate, _) => Some(chalk_ir::Binders::new(
+ ty::PredicateKind::Trait(predicate) => Some(chalk_ir::Binders::new(
binders,
chalk_solve::rust_ir::InlineBound::TraitBound(
predicate.trait_ref.lower_into(interner),
diff --git a/compiler/rustc_traits/src/type_op.rs b/compiler/rustc_traits/src/type_op.rs
index 2c55ea7f5c14e..f4a0cc6767f09 100644
--- a/compiler/rustc_traits/src/type_op.rs
+++ b/compiler/rustc_traits/src/type_op.rs
@@ -6,7 +6,9 @@ use rustc_infer::infer::{InferCtxt, TyCtxtInferExt};
use rustc_infer::traits::TraitEngineExt as _;
use rustc_middle::ty::query::Providers;
use rustc_middle::ty::subst::{GenericArg, Subst, UserSelfTy, UserSubsts};
-use rustc_middle::ty::{self, FnSig, Lift, PolyFnSig, Ty, TyCtxt, TypeFoldable, Variance};
+use rustc_middle::ty::{
+ self, FnSig, Lift, PolyFnSig, PredicateKind, Ty, TyCtxt, TypeFoldable, Variance,
+};
use rustc_middle::ty::{ParamEnv, ParamEnvAnd, Predicate, ToPredicate};
use rustc_span::DUMMY_SP;
use rustc_trait_selection::infer::InferCtxtBuilderExt;
@@ -85,7 +87,16 @@ impl AscribeUserTypeCx<'me, 'tcx> {
Ok(())
}
- fn prove_predicate(&mut self, predicate: Predicate<'tcx>) {
+ fn prove_predicate(&mut self, mut predicate: Predicate<'tcx>) {
+ if let PredicateKind::Trait(mut tr) = predicate.kind().skip_binder() {
+ if let hir::Constness::Const = tr.constness {
+ // FIXME check if we actually want to prove const predicates inside AscribeUserType
+ tr.constness = hir::Constness::NotConst;
+ predicate =
+ predicate.kind().rebind(PredicateKind::Trait(tr)).to_predicate(self.tcx());
+ }
+ }
+
self.fulfill_cx.register_predicate_obligation(
self.infcx,
Obligation::new(ObligationCause::dummy(), self.param_env, predicate),
@@ -126,6 +137,7 @@ impl AscribeUserTypeCx<'me, 'tcx> {
// outlives" error messages.
let instantiated_predicates =
self.tcx().predicates_of(def_id).instantiate(self.tcx(), substs);
+ debug!(?instantiated_predicates.predicates);
for instantiated_predicate in instantiated_predicates.predicates {
let instantiated_predicate = self.normalize(instantiated_predicate);
self.prove_predicate(instantiated_predicate);
diff --git a/compiler/rustc_typeck/src/astconv/mod.rs b/compiler/rustc_typeck/src/astconv/mod.rs
index 9871b14754e62..c091b21eae626 100644
--- a/compiler/rustc_typeck/src/astconv/mod.rs
+++ b/compiler/rustc_typeck/src/astconv/mod.rs
@@ -1339,7 +1339,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
let bound_predicate = obligation.predicate.kind();
match bound_predicate.skip_binder() {
- ty::PredicateKind::Trait(pred, _) => {
+ ty::PredicateKind::Trait(pred) => {
let pred = bound_predicate.rebind(pred);
associated_types.entry(span).or_default().extend(
tcx.associated_items(pred.def_id())
diff --git a/compiler/rustc_typeck/src/check/_match.rs b/compiler/rustc_typeck/src/check/_match.rs
index d056f2c90f988..cd12ab229e68a 100644
--- a/compiler/rustc_typeck/src/check/_match.rs
+++ b/compiler/rustc_typeck/src/check/_match.rs
@@ -603,16 +603,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let mut suggest_box = !impl_trait_ret_ty.obligations.is_empty();
for o in impl_trait_ret_ty.obligations {
match o.predicate.kind().skip_binder() {
- ty::PredicateKind::Trait(t, constness) => {
- let pred = ty::PredicateKind::Trait(
- ty::TraitPredicate {
- trait_ref: ty::TraitRef {
- def_id: t.def_id(),
- substs: self.infcx.tcx.mk_substs_trait(outer_ty, &[]),
- },
+ ty::PredicateKind::Trait(t) => {
+ let pred = ty::PredicateKind::Trait(ty::TraitPredicate {
+ trait_ref: ty::TraitRef {
+ def_id: t.def_id(),
+ substs: self.infcx.tcx.mk_substs_trait(outer_ty, &[]),
},
- constness,
- );
+ constness: t.constness,
+ });
let obl = Obligation::new(
o.cause.clone(),
self.param_env,
diff --git a/compiler/rustc_typeck/src/check/coercion.rs b/compiler/rustc_typeck/src/check/coercion.rs
index ba76b9c8dd5a0..167c2ddbb3dca 100644
--- a/compiler/rustc_typeck/src/check/coercion.rs
+++ b/compiler/rustc_typeck/src/check/coercion.rs
@@ -586,9 +586,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
debug!("coerce_unsized resolve step: {:?}", obligation);
let bound_predicate = obligation.predicate.kind();
let trait_pred = match bound_predicate.skip_binder() {
- ty::PredicateKind::Trait(trait_pred, _)
- if traits.contains(&trait_pred.def_id()) =>
- {
+ ty::PredicateKind::Trait(trait_pred) if traits.contains(&trait_pred.def_id()) => {
if unsize_did == trait_pred.def_id() {
let unsize_ty = trait_pred.trait_ref.substs[1].expect_ty();
if let ty::Tuple(..) = unsize_ty.kind() {
diff --git a/compiler/rustc_typeck/src/check/compare_method.rs b/compiler/rustc_typeck/src/check/compare_method.rs
index d35868881558e..316a097556aec 100644
--- a/compiler/rustc_typeck/src/check/compare_method.rs
+++ b/compiler/rustc_typeck/src/check/compare_method.rs
@@ -1292,7 +1292,13 @@ pub fn check_type_bounds<'tcx>(
};
tcx.infer_ctxt().enter(move |infcx| {
- let inh = Inherited::new(infcx, impl_ty.def_id.expect_local());
+ let constness = impl_ty
+ .container
+ .impl_def_id()
+ .map(|did| tcx.impl_constness(did))
+ .unwrap_or(hir::Constness::NotConst);
+
+ let inh = Inherited::with_constness(infcx, impl_ty.def_id.expect_local(), constness);
let infcx = &inh.infcx;
let mut selcx = traits::SelectionContext::new(&infcx);
@@ -1334,7 +1340,9 @@ pub fn check_type_bounds<'tcx>(
// Check that all obligations are satisfied by the implementation's
// version.
- if let Err(ref errors) = inh.fulfillment_cx.borrow_mut().select_all_or_error(&infcx) {
+ if let Err(ref errors) =
+ inh.fulfillment_cx.borrow_mut().select_all_with_constness_or_error(&infcx, constness)
+ {
infcx.report_fulfillment_errors(errors, None, false);
return Err(ErrorReported);
}
diff --git a/compiler/rustc_typeck/src/check/dropck.rs b/compiler/rustc_typeck/src/check/dropck.rs
index 01276495c185a..9514e599538f7 100644
--- a/compiler/rustc_typeck/src/check/dropck.rs
+++ b/compiler/rustc_typeck/src/check/dropck.rs
@@ -229,7 +229,7 @@ fn ensure_drop_predicates_are_implied_by_item_defn<'tcx>(
let predicate = predicate.kind();
let p = p.kind();
match (predicate.skip_binder(), p.skip_binder()) {
- (ty::PredicateKind::Trait(a, _), ty::PredicateKind::Trait(b, _)) => {
+ (ty::PredicateKind::Trait(a), ty::PredicateKind::Trait(b)) => {
relator.relate(predicate.rebind(a), p.rebind(b)).is_ok()
}
(ty::PredicateKind::Projection(a), ty::PredicateKind::Projection(b)) => {
diff --git a/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs b/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs
index f5776ae7cf66a..b6ed6b84aaf78 100644
--- a/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs
+++ b/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs
@@ -747,7 +747,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
pub(in super::super) fn select_all_obligations_or_error(&self) {
debug!("select_all_obligations_or_error");
- if let Err(errors) = self.fulfillment_cx.borrow_mut().select_all_or_error(&self) {
+ if let Err(errors) = self
+ .fulfillment_cx
+ .borrow_mut()
+ .select_all_with_constness_or_error(&self, self.inh.constness)
+ {
self.report_fulfillment_errors(&errors, self.inh.body_id, false);
}
}
@@ -758,7 +762,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
fallback_has_occurred: bool,
mutate_fulfillment_errors: impl Fn(&mut Vec<traits::FulfillmentError<'tcx>>),
) {
- let result = self.fulfillment_cx.borrow_mut().select_where_possible(self);
+ let result = self
+ .fulfillment_cx
+ .borrow_mut()
+ .select_with_constness_where_possible(self, self.inh.constness);
if let Err(mut errors) = result {
mutate_fulfillment_errors(&mut errors);
self.report_fulfillment_errors(&errors, self.inh.body_id, fallback_has_occurred);
@@ -829,7 +836,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
bound_predicate.rebind(data).required_poly_trait_ref(self.tcx),
obligation,
)),
- ty::PredicateKind::Trait(data, _) => {
+ ty::PredicateKind::Trait(data) => {
Some((bound_predicate.rebind(data).to_poly_trait_ref(), obligation))
}
ty::PredicateKind::Subtype(..) => None,
diff --git a/compiler/rustc_typeck/src/check/fn_ctxt/checks.rs b/compiler/rustc_typeck/src/check/fn_ctxt/checks.rs
index f65cc429fbd48..9952413353fa9 100644
--- a/compiler/rustc_typeck/src/check/fn_ctxt/checks.rs
+++ b/compiler/rustc_typeck/src/check/fn_ctxt/checks.rs
@@ -923,7 +923,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
continue;
}
- if let ty::PredicateKind::Trait(predicate, _) =
+ if let ty::PredicateKind::Trait(predicate) =
error.obligation.predicate.kind().skip_binder()
{
// Collect the argument position for all arguments that could have caused this
@@ -974,7 +974,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
if let hir::ExprKind::Path(qpath) = &path.kind {
if let hir::QPath::Resolved(_, path) = &qpath {
for error in errors {
- if let ty::PredicateKind::Trait(predicate, _) =
+ if let ty::PredicateKind::Trait(predicate) =
error.obligation.predicate.kind().skip_binder()
{
// If any of the type arguments in this path segment caused the
diff --git a/compiler/rustc_typeck/src/check/fn_ctxt/mod.rs b/compiler/rustc_typeck/src/check/fn_ctxt/mod.rs
index 13686cfec809a..c0ecee155c6dd 100644
--- a/compiler/rustc_typeck/src/check/fn_ctxt/mod.rs
+++ b/compiler/rustc_typeck/src/check/fn_ctxt/mod.rs
@@ -174,7 +174,7 @@ impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> {
}
fn default_constness_for_trait_bounds(&self) -> hir::Constness {
- self.tcx.hir().get(self.body_id).constness()
+ self.tcx.hir().get(self.body_id).constness_for_typeck()
}
fn get_type_parameter_bounds(
@@ -194,7 +194,7 @@ impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> {
predicates: tcx.arena.alloc_from_iter(
self.param_env.caller_bounds().iter().filter_map(|predicate| {
match predicate.kind().skip_binder() {
- ty::PredicateKind::Trait(data, _) if data.self_ty().is_param(index) => {
+ ty::PredicateKind::Trait(data) if data.self_ty().is_param(index) => {
// HACK(eddyb) should get the original `Span`.
let span = tcx.def_span(def_id);
Some((predicate, span))
diff --git a/compiler/rustc_typeck/src/check/inherited.rs b/compiler/rustc_typeck/src/check/inherited.rs
index 7e43e36fe55c6..9c05b42f1b0cb 100644
--- a/compiler/rustc_typeck/src/check/inherited.rs
+++ b/compiler/rustc_typeck/src/check/inherited.rs
@@ -68,6 +68,9 @@ pub struct Inherited<'a, 'tcx> {
/// opaque type.
pub(super) opaque_types_vars: RefCell<FxHashMap<Ty<'tcx>, Ty<'tcx>>>,
+ /// Reports whether this is in a const context.
+ pub(super) constness: hir::Constness,
+
pub(super) body_id: Option<hir::BodyId>,
}
@@ -109,6 +112,16 @@ impl<'tcx> InheritedBuilder<'tcx> {
impl Inherited<'a, 'tcx> {
pub(super) fn new(infcx: InferCtxt<'a, 'tcx>, def_id: LocalDefId) -> Self {
+ let tcx = infcx.tcx;
+ let item_id = tcx.hir().local_def_id_to_hir_id(def_id);
+ Self::with_constness(infcx, def_id, tcx.hir().get(item_id).constness_for_typeck())
+ }
+
+ pub(super) fn with_constness(
+ infcx: InferCtxt<'a, 'tcx>,
+ def_id: LocalDefId,
+ constness: hir::Constness,
+ ) -> Self {
let tcx = infcx.tcx;
let item_id = tcx.hir().local_def_id_to_hir_id(def_id);
let body_id = tcx.hir().maybe_body_owned_by(item_id);
@@ -126,6 +139,7 @@ impl Inherited<'a, 'tcx> {
deferred_generator_interiors: RefCell::new(Vec::new()),
opaque_types: RefCell::new(Default::default()),
opaque_types_vars: RefCell::new(Default::default()),
+ constness,
body_id,
}
}
diff --git a/compiler/rustc_typeck/src/check/method/confirm.rs b/compiler/rustc_typeck/src/check/method/confirm.rs
index 3aceaba882d6c..88be49e96e7be 100644
--- a/compiler/rustc_typeck/src/check/method/confirm.rs
+++ b/compiler/rustc_typeck/src/check/method/confirm.rs
@@ -507,7 +507,7 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
traits::elaborate_predicates(self.tcx, predicates.predicates.iter().copied())
// We don't care about regions here.
.filter_map(|obligation| match obligation.predicate.kind().skip_binder() {
- ty::PredicateKind::Trait(trait_pred, _) if trait_pred.def_id() == sized_def_id => {
+ ty::PredicateKind::Trait(trait_pred) if trait_pred.def_id() == sized_def_id => {
let span = iter::zip(&predicates.predicates, &predicates.spans)
.find_map(
|(p, span)| {
diff --git a/compiler/rustc_typeck/src/check/method/probe.rs b/compiler/rustc_typeck/src/check/method/probe.rs
index 9037ffe49a9a2..c6e6c8c5d70e2 100644
--- a/compiler/rustc_typeck/src/check/method/probe.rs
+++ b/compiler/rustc_typeck/src/check/method/probe.rs
@@ -832,7 +832,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
let bounds = self.param_env.caller_bounds().iter().filter_map(|predicate| {
let bound_predicate = predicate.kind();
match bound_predicate.skip_binder() {
- ty::PredicateKind::Trait(trait_predicate, _) => {
+ ty::PredicateKind::Trait(trait_predicate) => {
match *trait_predicate.trait_ref.self_ty().kind() {
ty::Param(p) if p == param_ty => {
Some(bound_predicate.rebind(trait_predicate.trait_ref))
diff --git a/compiler/rustc_typeck/src/check/method/suggest.rs b/compiler/rustc_typeck/src/check/method/suggest.rs
index 77586ce48529c..a1386741a598c 100644
--- a/compiler/rustc_typeck/src/check/method/suggest.rs
+++ b/compiler/rustc_typeck/src/check/method/suggest.rs
@@ -683,7 +683,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let mut collect_type_param_suggestions =
|self_ty: Ty<'tcx>, parent_pred: &ty::Predicate<'tcx>, obligation: &str| {
// We don't care about regions here, so it's fine to skip the binder here.
- if let (ty::Param(_), ty::PredicateKind::Trait(p, _)) =
+ if let (ty::Param(_), ty::PredicateKind::Trait(p)) =
(self_ty.kind(), parent_pred.kind().skip_binder())
{
if let ty::Adt(def, _) = p.trait_ref.self_ty().kind() {
@@ -763,7 +763,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
bound_span_label(projection_ty.self_ty(), &obligation, &quiet);
Some((obligation, projection_ty.self_ty()))
}
- ty::PredicateKind::Trait(poly_trait_ref, _) => {
+ ty::PredicateKind::Trait(poly_trait_ref) => {
let p = poly_trait_ref.trait_ref;
let self_ty = p.self_ty();
let path = p.print_only_trait_path();
@@ -1200,7 +1200,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
match p.kind().skip_binder() {
// Hide traits if they are present in predicates as they can be fixed without
// having to implement them.
- ty::PredicateKind::Trait(t, _) => t.def_id() == info.def_id,
+ ty::PredicateKind::Trait(t) => t.def_id() == info.def_id,
ty::PredicateKind::Projection(p) => {
p.projection_ty.item_def_id == info.def_id
}
diff --git a/compiler/rustc_typeck/src/check/mod.rs b/compiler/rustc_typeck/src/check/mod.rs
index d30b057e26fe3..47ed6745c8eed 100644
--- a/compiler/rustc_typeck/src/check/mod.rs
+++ b/compiler/rustc_typeck/src/check/mod.rs
@@ -695,7 +695,7 @@ fn bounds_from_generic_predicates<'tcx>(
debug!("predicate {:?}", predicate);
let bound_predicate = predicate.kind();
match bound_predicate.skip_binder() {
- ty::PredicateKind::Trait(trait_predicate, _) => {
+ ty::PredicateKind::Trait(trait_predicate) => {
let entry = types.entry(trait_predicate.self_ty()).or_default();
let def_id = trait_predicate.def_id();
if Some(def_id) != tcx.lang_items().sized_trait() {
diff --git a/compiler/rustc_typeck/src/collect.rs b/compiler/rustc_typeck/src/collect.rs
index 997fdcefe037a..a44c3d43e7f1c 100644
--- a/compiler/rustc_typeck/src/collect.rs
+++ b/compiler/rustc_typeck/src/collect.rs
@@ -367,7 +367,7 @@ impl AstConv<'tcx> for ItemCtxt<'tcx> {
}
fn default_constness_for_trait_bounds(&self) -> hir::Constness {
- self.node().constness()
+ self.node().constness_for_typeck()
}
fn get_type_parameter_bounds(
@@ -643,7 +643,7 @@ fn type_param_predicates(
)
.into_iter()
.filter(|(predicate, _)| match predicate.kind().skip_binder() {
- ty::PredicateKind::Trait(data, _) => data.self_ty().is_param(index),
+ ty::PredicateKind::Trait(data) => data.self_ty().is_param(index),
_ => false,
}),
);
@@ -1201,7 +1201,7 @@ fn super_predicates_that_define_assoc_type(
// which will, in turn, reach indirect supertraits.
for &(pred, span) in superbounds {
debug!("superbound: {:?}", pred);
- if let ty::PredicateKind::Trait(bound, _) = pred.kind().skip_binder() {
+ if let ty::PredicateKind::Trait(bound) = pred.kind().skip_binder() {
tcx.at(span).super_predicates_of(bound.def_id());
}
}
@@ -2438,7 +2438,7 @@ fn explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericPredicat
.iter()
.copied()
.filter(|(pred, _)| match pred.kind().skip_binder() {
- ty::PredicateKind::Trait(tr, _) => !is_assoc_item_ty(tr.self_ty()),
+ ty::PredicateKind::Trait(tr) => !is_assoc_item_ty(tr.self_ty()),
ty::PredicateKind::Projection(proj) => {
!is_assoc_item_ty(proj.projection_ty.self_ty())
}
diff --git a/compiler/rustc_typeck/src/collect/item_bounds.rs b/compiler/rustc_typeck/src/collect/item_bounds.rs
index a5b36445aae2e..1d08c4450afcf 100644
--- a/compiler/rustc_typeck/src/collect/item_bounds.rs
+++ b/compiler/rustc_typeck/src/collect/item_bounds.rs
@@ -38,7 +38,7 @@ fn associated_type_bounds<'tcx>(
let bounds_from_parent = trait_predicates.predicates.iter().copied().filter(|(pred, _)| {
match pred.kind().skip_binder() {
- ty::PredicateKind::Trait(tr, _) => tr.self_ty() == item_ty,
+ ty::PredicateKind::Trait(tr) => tr.self_ty() == item_ty,
ty::PredicateKind::Projection(proj) => proj.projection_ty.self_ty() == item_ty,
ty::PredicateKind::TypeOutlives(outlives) => outlives.0 == item_ty,
_ => false,
diff --git a/compiler/rustc_typeck/src/expr_use_visitor.rs b/compiler/rustc_typeck/src/expr_use_visitor.rs
index 6c76a8960bbe1..1d7852d964c1d 100644
--- a/compiler/rustc_typeck/src/expr_use_visitor.rs
+++ b/compiler/rustc_typeck/src/expr_use_visitor.rs
@@ -267,12 +267,21 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> {
}
}
}
- PatKind::Lit(_) => {
- // If the PatKind is a Lit then we want
+ PatKind::Lit(_) | PatKind::Range(..) => {
+ // If the PatKind is a Lit or a Range then we want
// to borrow discr.
needs_to_be_read = true;
}
- _ => {}
+ PatKind::Or(_)
+ | PatKind::Box(_)
+ | PatKind::Slice(..)
+ | PatKind::Ref(..)
+ | PatKind::Wild => {
+ // If the PatKind is Or, Box, Slice or Ref, the decision is made later
+ // as these patterns contains subpatterns
+ // If the PatKind is Wild, the decision is made based on the other patterns being
+ // examined
+ }
}
}));
}
diff --git a/compiler/rustc_typeck/src/impl_wf_check/min_specialization.rs b/compiler/rustc_typeck/src/impl_wf_check/min_specialization.rs
index 505d9a59d9c2f..d5d81603fc516 100644
--- a/compiler/rustc_typeck/src/impl_wf_check/min_specialization.rs
+++ b/compiler/rustc_typeck/src/impl_wf_check/min_specialization.rs
@@ -366,7 +366,10 @@ fn check_specialization_on<'tcx>(tcx: TyCtxt<'tcx>, predicate: ty::Predicate<'tc
_ if predicate.is_global() => (),
// We allow specializing on explicitly marked traits with no associated
// items.
- ty::PredicateKind::Trait(pred, hir::Constness::NotConst) => {
+ ty::PredicateKind::Trait(ty::TraitPredicate {
+ trait_ref,
+ constness: hir::Constness::NotConst,
+ }) => {
if !matches!(
trait_predicate_kind(tcx, predicate),
Some(TraitSpecializationKind::Marker)
@@ -376,7 +379,7 @@ fn check_specialization_on<'tcx>(tcx: TyCtxt<'tcx>, predicate: ty::Predicate<'tc
span,
&format!(
"cannot specialize on trait `{}`",
- tcx.def_path_str(pred.def_id()),
+ tcx.def_path_str(trait_ref.def_id),
),
)
.emit()
@@ -394,10 +397,11 @@ fn trait_predicate_kind<'tcx>(
predicate: ty::Predicate<'tcx>,
) -> Option<TraitSpecializationKind> {
match predicate.kind().skip_binder() {
- ty::PredicateKind::Trait(pred, hir::Constness::NotConst) => {
- Some(tcx.trait_def(pred.def_id()).specialization_kind)
- }
- ty::PredicateKind::Trait(_, hir::Constness::Const)
+ ty::PredicateKind::Trait(ty::TraitPredicate {
+ trait_ref,
+ constness: hir::Constness::NotConst,
+ }) => Some(tcx.trait_def(trait_ref.def_id).specialization_kind),
+ ty::PredicateKind::Trait(_)
| ty::PredicateKind::RegionOutlives(_)
| ty::PredicateKind::TypeOutlives(_)
| ty::PredicateKind::Projection(_)
diff --git a/library/alloc/src/collections/btree/map/tests.rs b/library/alloc/src/collections/btree/map/tests.rs
index 1e61692b7c63c..17e538483431c 100644
--- a/library/alloc/src/collections/btree/map/tests.rs
+++ b/library/alloc/src/collections/btree/map/tests.rs
@@ -1786,13 +1786,6 @@ fn test_ord_absence() {
}
}
-#[allow(dead_code)]
-fn test_const() {
- const MAP: &'static BTreeMap<(), ()> = &BTreeMap::new();
- const LEN: usize = MAP.len();
- const IS_EMPTY: bool = MAP.is_empty();
-}
-
#[test]
fn test_occupied_entry_key() {
let mut a = BTreeMap::new();
diff --git a/library/alloc/src/collections/btree/set/tests.rs b/library/alloc/src/collections/btree/set/tests.rs
index de7a10dca7b8c..5d590a26281d2 100644
--- a/library/alloc/src/collections/btree/set/tests.rs
+++ b/library/alloc/src/collections/btree/set/tests.rs
@@ -16,13 +16,6 @@ fn test_clone_eq() {
assert_eq!(m.clone(), m);
}
-#[allow(dead_code)]
-fn test_const() {
- const SET: &'static BTreeSet<()> = &BTreeSet::new();
- const LEN: usize = SET.len();
- const IS_EMPTY: bool = SET.is_empty();
-}
-
#[test]
fn test_iter_min_max() {
let mut a = BTreeSet::new();
diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs
index 2b380c444b8ab..58dd0b7ebcc44 100644
--- a/library/alloc/src/vec/mod.rs
+++ b/library/alloc/src/vec/mod.rs
@@ -1372,9 +1372,11 @@ impl<T, A: Allocator> Vec<T, A> {
/// assert_eq!(v, [1, 3]);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
+ #[track_caller]
pub fn remove(&mut self, index: usize) -> T {
#[cold]
#[inline(never)]
+ #[track_caller]
fn assert_failed(index: usize, len: usize) -> ! {
panic!("removal index (is {}) should be < len (is {})", index, len);
}
diff --git a/library/alloc/tests/const_fns.rs b/library/alloc/tests/const_fns.rs
new file mode 100644
index 0000000000000..02e8f8f40228f
--- /dev/null
+++ b/library/alloc/tests/const_fns.rs
@@ -0,0 +1,53 @@
+// Test several functions can be used for constants
+// 1. Vec::new()
+// 2. String::new()
+// 3. BTreeMap::new()
+// 4. BTreeSet::new()
+
+#[allow(dead_code)]
+pub const MY_VEC: Vec<usize> = Vec::new();
+
+#[allow(dead_code)]
+pub const MY_STRING: String = String::new();
+
+// FIXME remove this struct once we put `K: ?const Ord` on BTreeMap::new.
+#[derive(PartialEq, Eq, PartialOrd)]
+pub struct MyType;
+
+impl const Ord for MyType {
+ fn cmp(&self, _: &Self) -> Ordering {
+ Ordering::Equal
+ }
+
+ fn max(self, _: Self) -> Self {
+ Self
+ }
+
+ fn min(self, _: Self) -> Self {
+ Self
+ }
+
+ fn clamp(self, _: Self, _: Self) -> Self {
+ Self
+ }
+}
+
+use core::cmp::Ordering;
+use std::collections::{BTreeMap, BTreeSet};
+
+pub const MY_BTREEMAP: BTreeMap<MyType, MyType> = BTreeMap::new();
+pub const MAP: &'static BTreeMap<MyType, MyType> = &MY_BTREEMAP;
+pub const MAP_LEN: usize = MAP.len();
+pub const MAP_IS_EMPTY: bool = MAP.is_empty();
+
+pub const MY_BTREESET: BTreeSet<MyType> = BTreeSet::new();
+pub const SET: &'static BTreeSet<MyType> = &MY_BTREESET;
+pub const SET_LEN: usize = SET.len();
+pub const SET_IS_EMPTY: bool = SET.is_empty();
+
+#[test]
+fn test_const() {
+ assert_eq!(MAP_LEN, 0);
+ assert_eq!(SET_LEN, 0);
+ assert!(MAP_IS_EMPTY && SET_IS_EMPTY)
+}
diff --git a/library/alloc/tests/lib.rs b/library/alloc/tests/lib.rs
index 3143afa269dde..f2f5b595d02bf 100644
--- a/library/alloc/tests/lib.rs
+++ b/library/alloc/tests/lib.rs
@@ -21,6 +21,10 @@
#![feature(slice_partition_dedup)]
#![feature(vec_spare_capacity)]
#![feature(string_remove_matches)]
+#![feature(const_btree_new)]
+#![feature(const_trait_impl)]
+// FIXME remove this when const_trait_impl is not incomplete anymore
+#![allow(incomplete_features)]
use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};
@@ -30,6 +34,7 @@ mod binary_heap;
mod borrow;
mod boxed;
mod btree_set_hash;
+mod const_fns;
mod cow_str;
mod fmt;
mod heap;
diff --git a/library/core/src/num/diy_float.rs b/library/core/src/num/diy_float.rs
index 0a609417dcf4c..ce7f6475d0599 100644
--- a/library/core/src/num/diy_float.rs
+++ b/library/core/src/num/diy_float.rs
@@ -65,7 +65,7 @@ impl Fp {
f <<= 1;
e -= 1;
}
- debug_assert!(f >= (1 >> 63));
+ debug_assert!(f >= (1 << 63));
Fp { f, e }
}
diff --git a/library/std/src/io/buffered/bufwriter.rs b/library/std/src/io/buffered/bufwriter.rs
index c98244132befd..9da5fbff9cf02 100644
--- a/library/std/src/io/buffered/bufwriter.rs
+++ b/library/std/src/io/buffered/bufwriter.rs
@@ -307,7 +307,7 @@ impl<W: Write> BufWriter<W> {
pub fn into_inner(mut self) -> Result<W, IntoInnerError<BufWriter<W>>> {
match self.flush_buf() {
Err(e) => Err(IntoInnerError::new(self, e)),
- Ok(()) => Ok(self.into_raw_parts().0),
+ Ok(()) => Ok(self.into_parts().0),
}
}
@@ -318,24 +318,24 @@ impl<W: Write> BufWriter<W> {
/// In this case, we return `WriterPanicked` for the buffered data (from which the buffer
/// contents can still be recovered).
///
- /// `into_raw_parts` makes no attempt to flush data and cannot fail.
+ /// `into_parts` makes no attempt to flush data and cannot fail.
///
/// # Examples
///
/// ```
- /// #![feature(bufwriter_into_raw_parts)]
+ /// #![feature(bufwriter_into_parts)]
/// use std::io::{BufWriter, Write};
///
/// let mut buffer = [0u8; 10];
/// let mut stream = BufWriter::new(buffer.as_mut());
/// write!(stream, "too much data").unwrap();
/// stream.flush().expect_err("it doesn't fit");
- /// let (recovered_writer, buffered_data) = stream.into_raw_parts();
+ /// let (recovered_writer, buffered_data) = stream.into_parts();
/// assert_eq!(recovered_writer.len(), 0);
/// assert_eq!(&buffered_data.unwrap(), b"ata");
/// ```
- #[unstable(feature = "bufwriter_into_raw_parts", issue = "80690")]
- pub fn into_raw_parts(mut self) -> (W, Result<Vec<u8>, WriterPanicked>) {
+ #[unstable(feature = "bufwriter_into_parts", issue = "80690")]
+ pub fn into_parts(mut self) -> (W, Result<Vec<u8>, WriterPanicked>) {
let buf = mem::take(&mut self.buf);
let buf = if !self.panicked { Ok(buf) } else { Err(WriterPanicked { buf }) };
@@ -444,14 +444,14 @@ impl<W: Write> BufWriter<W> {
}
}
-#[unstable(feature = "bufwriter_into_raw_parts", issue = "80690")]
-/// Error returned for the buffered data from `BufWriter::into_raw_parts`, when the underlying
+#[unstable(feature = "bufwriter_into_parts", issue = "80690")]
+/// Error returned for the buffered data from `BufWriter::into_parts`, when the underlying
/// writer has previously panicked. Contains the (possibly partly written) buffered data.
///
/// # Example
///
/// ```
-/// #![feature(bufwriter_into_raw_parts)]
+/// #![feature(bufwriter_into_parts)]
/// use std::io::{self, BufWriter, Write};
/// use std::panic::{catch_unwind, AssertUnwindSafe};
///
@@ -467,7 +467,7 @@ impl<W: Write> BufWriter<W> {
/// stream.flush().unwrap()
/// }));
/// assert!(result.is_err());
-/// let (recovered_writer, buffered_data) = stream.into_raw_parts();
+/// let (recovered_writer, buffered_data) = stream.into_parts();
/// assert!(matches!(recovered_writer, PanickingWriter));
/// assert_eq!(buffered_data.unwrap_err().into_inner(), b"some data");
/// ```
@@ -478,7 +478,7 @@ pub struct WriterPanicked {
impl WriterPanicked {
/// Returns the perhaps-unwritten data. Some of this data may have been written by the
/// panicking call(s) to the underlying writer, so simply writing it again is not a good idea.
- #[unstable(feature = "bufwriter_into_raw_parts", issue = "80690")]
+ #[unstable(feature = "bufwriter_into_parts", issue = "80690")]
pub fn into_inner(self) -> Vec<u8> {
self.buf
}
@@ -487,7 +487,7 @@ impl WriterPanicked {
"BufWriter inner writer panicked, what data remains unwritten is not known";
}
-#[unstable(feature = "bufwriter_into_raw_parts", issue = "80690")]
+#[unstable(feature = "bufwriter_into_parts", issue = "80690")]
impl error::Error for WriterPanicked {
#[allow(deprecated, deprecated_in_future)]
fn description(&self) -> &str {
@@ -495,14 +495,14 @@ impl error::Error for WriterPanicked {
}
}
-#[unstable(feature = "bufwriter_into_raw_parts", issue = "80690")]
+#[unstable(feature = "bufwriter_into_parts", issue = "80690")]
impl fmt::Display for WriterPanicked {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", Self::DESCRIPTION)
}
}
-#[unstable(feature = "bufwriter_into_raw_parts", issue = "80690")]
+#[unstable(feature = "bufwriter_into_parts", issue = "80690")]
impl fmt::Debug for WriterPanicked {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("WriterPanicked")
diff --git a/library/std/src/io/buffered/mod.rs b/library/std/src/io/buffered/mod.rs
index 38076ab3a2b7b..8cfffc2fd35a4 100644
--- a/library/std/src/io/buffered/mod.rs
+++ b/library/std/src/io/buffered/mod.rs
@@ -14,6 +14,8 @@ use crate::io::Error;
pub use bufreader::BufReader;
pub use bufwriter::BufWriter;
+#[unstable(feature = "bufwriter_into_parts", issue = "80690")]
+pub use bufwriter::WriterPanicked;
pub use linewriter::LineWriter;
use linewritershim::LineWriterShim;
diff --git a/library/std/src/io/mod.rs b/library/std/src/io/mod.rs
index cc615b95f8625..c58abf2a737a3 100644
--- a/library/std/src/io/mod.rs
+++ b/library/std/src/io/mod.rs
@@ -264,6 +264,8 @@ use crate::sys_common::memchr;
#[stable(feature = "rust1", since = "1.0.0")]
pub use self::buffered::IntoInnerError;
+#[unstable(feature = "bufwriter_into_parts", issue = "80690")]
+pub use self::buffered::WriterPanicked;
#[stable(feature = "rust1", since = "1.0.0")]
pub use self::buffered::{BufReader, BufWriter, LineWriter};
#[stable(feature = "rust1", since = "1.0.0")]
diff --git a/library/std/src/macros.rs b/library/std/src/macros.rs
index 7afe52a3fd693..676695795badc 100644
--- a/library/std/src/macros.rs
+++ b/library/std/src/macros.rs
@@ -290,7 +290,7 @@ macro_rules! dbg {
// `$val` expression could be a block (`{ .. }`), in which case the `eprintln!`
// will be malformed.
() => {
- $crate::eprintln!("[{}:{}]", $crate::file!(), $crate::line!());
+ $crate::eprintln!("[{}:{}]", $crate::file!(), $crate::line!())
};
($val:expr $(,)?) => {
// Use of `match` here is intentional because it affects the lifetimes
diff --git a/src/librustdoc/clean/auto_trait.rs b/src/librustdoc/clean/auto_trait.rs
index e479d162b8ffb..58a87673241f5 100644
--- a/src/librustdoc/clean/auto_trait.rs
+++ b/src/librustdoc/clean/auto_trait.rs
@@ -316,7 +316,7 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
let bound_predicate = pred.kind();
let tcx = self.cx.tcx;
let regions = match bound_predicate.skip_binder() {
- ty::PredicateKind::Trait(poly_trait_pred, _) => {
+ ty::PredicateKind::Trait(poly_trait_pred) => {
tcx.collect_referenced_late_bound_regions(&bound_predicate.rebind(poly_trait_pred))
}
ty::PredicateKind::Projection(poly_proj_pred) => {
@@ -463,7 +463,7 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
.filter(|p| {
!orig_bounds.contains(p)
|| match p.kind().skip_binder() {
- ty::PredicateKind::Trait(pred, _) => pred.def_id() == sized_trait,
+ ty::PredicateKind::Trait(pred) => pred.def_id() == sized_trait,
_ => false,
}
})
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index fd79292477cab..da2fa6002ad39 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -323,7 +323,7 @@ impl<'a> Clean<Option<WherePredicate>> for ty::Predicate<'a> {
fn clean(&self, cx: &mut DocContext<'_>) -> Option<WherePredicate> {
let bound_predicate = self.kind();
match bound_predicate.skip_binder() {
- ty::PredicateKind::Trait(pred, _) => Some(bound_predicate.rebind(pred).clean(cx)),
+ ty::PredicateKind::Trait(pred) => Some(bound_predicate.rebind(pred).clean(cx)),
ty::PredicateKind::RegionOutlives(pred) => pred.clean(cx),
ty::PredicateKind::TypeOutlives(pred) => pred.clean(cx),
ty::PredicateKind::Projection(pred) => Some(pred.clean(cx)),
@@ -629,7 +629,7 @@ impl<'a, 'tcx> Clean<Generics> for (&'a ty::Generics, ty::GenericPredicates<'tcx
let param_idx = (|| {
let bound_p = p.kind();
match bound_p.skip_binder() {
- ty::PredicateKind::Trait(pred, _constness) => {
+ ty::PredicateKind::Trait(pred) => {
if let ty::Param(param) = pred.self_ty().kind() {
return Some(param.index);
}
@@ -1548,9 +1548,7 @@ impl<'tcx> Clean<Type> for Ty<'tcx> {
.filter_map(|bound| {
let bound_predicate = bound.kind();
let trait_ref = match bound_predicate.skip_binder() {
- ty::PredicateKind::Trait(tr, _constness) => {
- bound_predicate.rebind(tr.trait_ref)
- }
+ ty::PredicateKind::Trait(tr) => bound_predicate.rebind(tr.trait_ref),
ty::PredicateKind::TypeOutlives(ty::OutlivesPredicate(_ty, reg)) => {
if let Some(r) = reg.clean(cx) {
regions.push(GenericBound::Outlives(r));
diff --git a/src/librustdoc/clean/simplify.rs b/src/librustdoc/clean/simplify.rs
index 3ec0a22a2c09a..c0d52d349280f 100644
--- a/src/librustdoc/clean/simplify.rs
+++ b/src/librustdoc/clean/simplify.rs
@@ -139,7 +139,7 @@ fn trait_is_same_or_supertrait(cx: &DocContext<'_>, child: DefId, trait_: DefId)
.predicates
.iter()
.filter_map(|(pred, _)| {
- if let ty::PredicateKind::Trait(pred, _) = pred.kind().skip_binder() {
+ if let ty::PredicateKind::Trait(pred) = pred.kind().skip_binder() {
if pred.trait_ref.self_ty() == self_ty { Some(pred.def_id()) } else { None }
} else {
None
diff --git a/src/librustdoc/passes/collect_intra_doc_links.rs b/src/librustdoc/passes/collect_intra_doc_links.rs
index 21bd3ebd21bc8..ddb7b85d34a04 100644
--- a/src/librustdoc/passes/collect_intra_doc_links.rs
+++ b/src/librustdoc/passes/collect_intra_doc_links.rs
@@ -19,7 +19,7 @@ use rustc_resolve::ParentScope;
use rustc_session::lint::Lint;
use rustc_span::hygiene::{MacroKind, SyntaxContext};
use rustc_span::symbol::{sym, Ident, Symbol};
-use rustc_span::DUMMY_SP;
+use rustc_span::{BytePos, DUMMY_SP};
use smallvec::{smallvec, SmallVec};
use pulldown_cmark::LinkType;
@@ -1193,7 +1193,7 @@ impl LinkCollector<'_, '_> {
let report_mismatch = |specified: Disambiguator, resolved: Disambiguator| {
// The resolved item did not match the disambiguator; give a better error than 'not found'
let msg = format!("incompatible link kind for `{}`", path_str);
- let callback = |diag: &mut DiagnosticBuilder<'_>, sp| {
+ let callback = |diag: &mut DiagnosticBuilder<'_>, sp: Option<rustc_span::Span>| {
let note = format!(
"this link resolved to {} {}, which is not {} {}",
resolved.article(),
@@ -1201,8 +1201,12 @@ impl LinkCollector<'_, '_> {
specified.article(),
specified.descr()
);
- diag.note(¬e);
- suggest_disambiguator(resolved, diag, path_str, dox, sp, &ori_link.range);
+ if let Some(sp) = sp {
+ diag.span_label(sp, ¬e);
+ } else {
+ diag.note(¬e);
+ }
+ suggest_disambiguator(resolved, diag, path_str, &ori_link.link, sp);
};
report_diagnostic(self.cx.tcx, BROKEN_INTRA_DOC_LINKS, &msg, &diag_info, callback);
};
@@ -1699,6 +1703,51 @@ impl Suggestion {
Self::RemoveDisambiguator => path_str.into(),
}
}
+
+ fn as_help_span(
+ &self,
+ path_str: &str,
+ ori_link: &str,
+ sp: rustc_span::Span,
+ ) -> Vec<(rustc_span::Span, String)> {
+ let inner_sp = match ori_link.find('(') {
+ Some(index) => sp.with_hi(sp.lo() + BytePos(index as _)),
+ None => sp,
+ };
+ let inner_sp = match ori_link.find('!') {
+ Some(index) => inner_sp.with_hi(inner_sp.lo() + BytePos(index as _)),
+ None => inner_sp,
+ };
+ let inner_sp = match ori_link.find('@') {
+ Some(index) => inner_sp.with_lo(inner_sp.lo() + BytePos(index as u32 + 1)),
+ None => inner_sp,
+ };
+ match self {
+ Self::Prefix(prefix) => {
+ // FIXME: if this is an implied shortcut link, it's bad style to suggest `@`
+ let mut sugg = vec![(sp.with_hi(inner_sp.lo()), format!("{}@", prefix))];
+ if sp.hi() != inner_sp.hi() {
+ sugg.push((inner_sp.shrink_to_hi().with_hi(sp.hi()), String::new()));
+ }
+ sugg
+ }
+ Self::Function => {
+ let mut sugg = vec![(inner_sp.shrink_to_hi().with_hi(sp.hi()), "()".to_string())];
+ if sp.lo() != inner_sp.lo() {
+ sugg.push((inner_sp.shrink_to_lo().with_lo(sp.lo()), String::new()));
+ }
+ sugg
+ }
+ Self::Macro => {
+ let mut sugg = vec![(inner_sp.shrink_to_hi(), "!".to_string())];
+ if sp.lo() != inner_sp.lo() {
+ sugg.push((inner_sp.shrink_to_lo().with_lo(sp.lo()), String::new()));
+ }
+ sugg
+ }
+ Self::RemoveDisambiguator => return vec![(sp, path_str.into())],
+ }
+ }
}
/// Reports a diagnostic for an intra-doc link.
@@ -1732,7 +1781,16 @@ fn report_diagnostic(
tcx.struct_span_lint_hir(lint, hir_id, sp, |lint| {
let mut diag = lint.build(msg);
- let span = super::source_span_for_markdown_range(tcx, dox, link_range, &item.attrs);
+ let span =
+ super::source_span_for_markdown_range(tcx, dox, link_range, &item.attrs).map(|sp| {
+ if dox.bytes().nth(link_range.start) == Some(b'`')
+ && dox.bytes().nth(link_range.end - 1) == Some(b'`')
+ {
+ sp.with_lo(sp.lo() + BytePos(1)).with_hi(sp.hi() - BytePos(1))
+ } else {
+ sp
+ }
+ });
if let Some(sp) = span {
diag.set_span(sp);
@@ -1938,9 +1996,8 @@ fn resolution_failure(
disambiguator,
diag,
path_str,
- diag_info.dox,
+ diag_info.ori_link,
sp,
- &diag_info.link_range,
)
}
@@ -2007,7 +2064,7 @@ fn anchor_failure(cx: &DocContext<'_>, diag_info: DiagnosticInfo<'_>, failure: A
if let Some((fragment_offset, _)) =
diag_info.ori_link.char_indices().filter(|(_, x)| *x == '#').nth(anchor_idx)
{
- sp = sp.with_lo(sp.lo() + rustc_span::BytePos(fragment_offset as _));
+ sp = sp.with_lo(sp.lo() + BytePos(fragment_offset as _));
}
diag.span_label(sp, "invalid anchor");
}
@@ -2075,14 +2132,7 @@ fn ambiguity_error(
for res in candidates {
let disambiguator = Disambiguator::from_res(res);
- suggest_disambiguator(
- disambiguator,
- diag,
- path_str,
- diag_info.dox,
- sp,
- &diag_info.link_range,
- );
+ suggest_disambiguator(disambiguator, diag, path_str, diag_info.ori_link, sp);
}
});
}
@@ -2093,21 +2143,20 @@ fn suggest_disambiguator(
disambiguator: Disambiguator,
diag: &mut DiagnosticBuilder<'_>,
path_str: &str,
- dox: &str,
+ ori_link: &str,
sp: Option<rustc_span::Span>,
- link_range: &Range<usize>,
) {
let suggestion = disambiguator.suggestion();
let help = format!("to link to the {}, {}", disambiguator.descr(), suggestion.descr());
if let Some(sp) = sp {
- let msg = if dox.bytes().nth(link_range.start) == Some(b'`') {
- format!("`{}`", suggestion.as_help(path_str))
+ let mut spans = suggestion.as_help_span(path_str, ori_link, sp);
+ if spans.len() > 1 {
+ diag.multipart_suggestion(&help, spans, Applicability::MaybeIncorrect);
} else {
- suggestion.as_help(path_str)
- };
-
- diag.span_suggestion(sp, &help, msg, Applicability::MaybeIncorrect);
+ let (sp, suggestion_text) = spans.pop().unwrap();
+ diag.span_suggestion_verbose(sp, &help, suggestion_text, Applicability::MaybeIncorrect);
+ }
} else {
diag.help(&format!("{}: {}", help, suggestion.as_help(path_str)));
}
diff --git a/src/test/rustdoc-ui/assoc-item-not-in-scope.stderr b/src/test/rustdoc-ui/assoc-item-not-in-scope.stderr
index 358871b532313..04594ad414250 100644
--- a/src/test/rustdoc-ui/assoc-item-not-in-scope.stderr
+++ b/src/test/rustdoc-ui/assoc-item-not-in-scope.stderr
@@ -1,8 +1,8 @@
error: unresolved link to `S::fmt`
- --> $DIR/assoc-item-not-in-scope.rs:4:14
+ --> $DIR/assoc-item-not-in-scope.rs:4:15
|
LL | /// Link to [`S::fmt`]
- | ^^^^^^^^ the struct `S` has no field or associated item named `fmt`
+ | ^^^^^^ the struct `S` has no field or associated item named `fmt`
|
note: the lint level is defined here
--> $DIR/assoc-item-not-in-scope.rs:1:9
diff --git a/src/test/rustdoc-ui/intra-doc/ambiguity.stderr b/src/test/rustdoc-ui/intra-doc/ambiguity.stderr
index 0f23b9b8adf67..e87c26e9cc5b0 100644
--- a/src/test/rustdoc-ui/intra-doc/ambiguity.stderr
+++ b/src/test/rustdoc-ui/intra-doc/ambiguity.stderr
@@ -12,26 +12,26 @@ LL | #![deny(rustdoc::broken_intra_doc_links)]
help: to link to the module, prefix with `mod@`
|
LL | /// [mod@true]
- | ^^^^^^^^
+ | ^^^^
help: to link to the builtin type, prefix with `prim@`
|
LL | /// [prim@true]
- | ^^^^^^^^^
+ | ^^^^^
error: `ambiguous` is both a struct and a function
- --> $DIR/ambiguity.rs:27:6
+ --> $DIR/ambiguity.rs:27:7
|
LL | /// [`ambiguous`] is ambiguous.
- | ^^^^^^^^^^^ ambiguous link
+ | ^^^^^^^^^ ambiguous link
|
help: to link to the struct, prefix with `struct@`
|
LL | /// [`struct@ambiguous`] is ambiguous.
- | ^^^^^^^^^^^^^^^^^^
+ | ^^^^^^^
help: to link to the function, add parentheses
|
LL | /// [`ambiguous()`] is ambiguous.
- | ^^^^^^^^^^^^^
+ | ^^
error: `ambiguous` is both a struct and a function
--> $DIR/ambiguity.rs:29:6
@@ -42,30 +42,30 @@ LL | /// [ambiguous] is ambiguous.
help: to link to the struct, prefix with `struct@`
|
LL | /// [struct@ambiguous] is ambiguous.
- | ^^^^^^^^^^^^^^^^
+ | ^^^^^^^
help: to link to the function, add parentheses
|
LL | /// [ambiguous()] is ambiguous.
- | ^^^^^^^^^^^
+ | ^^
error: `multi_conflict` is a struct, a function, and a macro
- --> $DIR/ambiguity.rs:31:6
+ --> $DIR/ambiguity.rs:31:7
|
LL | /// [`multi_conflict`] is a three-way conflict.
- | ^^^^^^^^^^^^^^^^ ambiguous link
+ | ^^^^^^^^^^^^^^ ambiguous link
|
help: to link to the struct, prefix with `struct@`
|
LL | /// [`struct@multi_conflict`] is a three-way conflict.
- | ^^^^^^^^^^^^^^^^^^^^^^^
+ | ^^^^^^^
help: to link to the function, add parentheses
|
LL | /// [`multi_conflict()`] is a three-way conflict.
- | ^^^^^^^^^^^^^^^^^^
+ | ^^
help: to link to the macro, add an exclamation mark
|
LL | /// [`multi_conflict!`] is a three-way conflict.
- | ^^^^^^^^^^^^^^^^^
+ | ^
error: `type_and_value` is both a module and a constant
--> $DIR/ambiguity.rs:33:16
@@ -76,26 +76,26 @@ LL | /// Ambiguous [type_and_value].
help: to link to the module, prefix with `mod@`
|
LL | /// Ambiguous [mod@type_and_value].
- | ^^^^^^^^^^^^^^^^^^
+ | ^^^^
help: to link to the constant, prefix with `const@`
|
LL | /// Ambiguous [const@type_and_value].
- | ^^^^^^^^^^^^^^^^^^^^
+ | ^^^^^^
error: `foo::bar` is both an enum and a function
- --> $DIR/ambiguity.rs:35:42
+ --> $DIR/ambiguity.rs:35:43
|
LL | /// Ambiguous non-implied shortcut link [`foo::bar`].
- | ^^^^^^^^^^ ambiguous link
+ | ^^^^^^^^ ambiguous link
|
help: to link to the enum, prefix with `enum@`
|
LL | /// Ambiguous non-implied shortcut link [`enum@foo::bar`].
- | ^^^^^^^^^^^^^^^
+ | ^^^^^
help: to link to the function, add parentheses
|
LL | /// Ambiguous non-implied shortcut link [`foo::bar()`].
- | ^^^^^^^^^^^^
+ | ^^
error: aborting due to 6 previous errors
diff --git a/src/test/rustdoc-ui/intra-doc/disambiguator-mismatch.rs b/src/test/rustdoc-ui/intra-doc/disambiguator-mismatch.rs
index 596623190a33f..142008cf76508 100644
--- a/src/test/rustdoc-ui/intra-doc/disambiguator-mismatch.rs
+++ b/src/test/rustdoc-ui/intra-doc/disambiguator-mismatch.rs
@@ -1,7 +1,9 @@
#![deny(rustdoc::broken_intra_doc_links)]
//~^ NOTE lint level is defined
pub enum S {}
+fn S() {}
+#[macro_export]
macro_rules! m {
() => {};
}
@@ -41,6 +43,12 @@ trait T {}
//~| NOTE this link resolved
//~| HELP add an exclamation mark
+/// Link to [m()]
+//~^ ERROR unresolved link to `m`
+//~| NOTE this link resolves to the macro `m`
+//~| HELP add an exclamation mark
+/// and to [m!()]
+
/// Link to [const@s]
//~^ ERROR incompatible link kind for `s`
//~| NOTE this link resolved
diff --git a/src/test/rustdoc-ui/intra-doc/disambiguator-mismatch.stderr b/src/test/rustdoc-ui/intra-doc/disambiguator-mismatch.stderr
index 5d4d4a699e4f3..8d1519516ee76 100644
--- a/src/test/rustdoc-ui/intra-doc/disambiguator-mismatch.stderr
+++ b/src/test/rustdoc-ui/intra-doc/disambiguator-mismatch.stderr
@@ -1,95 +1,139 @@
error: incompatible link kind for `S`
- --> $DIR/disambiguator-mismatch.rs:14:14
+ --> $DIR/disambiguator-mismatch.rs:16:14
|
LL | /// Link to [struct@S]
- | ^^^^^^^^ help: to link to the enum, prefix with `enum@`: `enum@S`
+ | ^^^^^^^^ this link resolved to an enum, which is not a struct
|
note: the lint level is defined here
--> $DIR/disambiguator-mismatch.rs:1:9
|
LL | #![deny(rustdoc::broken_intra_doc_links)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- = note: this link resolved to an enum, which is not a struct
+help: to link to the enum, prefix with `enum@`
+ |
+LL | /// Link to [enum@S]
+ | ^^^^^
error: incompatible link kind for `S`
- --> $DIR/disambiguator-mismatch.rs:19:14
+ --> $DIR/disambiguator-mismatch.rs:21:14
|
LL | /// Link to [mod@S]
- | ^^^^^ help: to link to the enum, prefix with `enum@`: `enum@S`
+ | ^^^^^ this link resolved to an enum, which is not a module
+ |
+help: to link to the enum, prefix with `enum@`
|
- = note: this link resolved to an enum, which is not a module
+LL | /// Link to [enum@S]
+ | ^^^^^
error: incompatible link kind for `S`
- --> $DIR/disambiguator-mismatch.rs:24:14
+ --> $DIR/disambiguator-mismatch.rs:26:14
|
LL | /// Link to [union@S]
- | ^^^^^^^ help: to link to the enum, prefix with `enum@`: `enum@S`
+ | ^^^^^^^ this link resolved to an enum, which is not a union
|
- = note: this link resolved to an enum, which is not a union
+help: to link to the enum, prefix with `enum@`
+ |
+LL | /// Link to [enum@S]
+ | ^^^^^
error: incompatible link kind for `S`
- --> $DIR/disambiguator-mismatch.rs:29:14
+ --> $DIR/disambiguator-mismatch.rs:31:14
|
LL | /// Link to [trait@S]
- | ^^^^^^^ help: to link to the enum, prefix with `enum@`: `enum@S`
+ | ^^^^^^^ this link resolved to an enum, which is not a trait
+ |
+help: to link to the enum, prefix with `enum@`
|
- = note: this link resolved to an enum, which is not a trait
+LL | /// Link to [enum@S]
+ | ^^^^^
error: incompatible link kind for `T`
- --> $DIR/disambiguator-mismatch.rs:34:14
+ --> $DIR/disambiguator-mismatch.rs:36:14
|
LL | /// Link to [struct@T]
- | ^^^^^^^^ help: to link to the trait, prefix with `trait@`: `trait@T`
+ | ^^^^^^^^ this link resolved to a trait, which is not a struct
|
- = note: this link resolved to a trait, which is not a struct
+help: to link to the trait, prefix with `trait@`
+ |
+LL | /// Link to [trait@T]
+ | ^^^^^^
error: incompatible link kind for `m`
- --> $DIR/disambiguator-mismatch.rs:39:14
+ --> $DIR/disambiguator-mismatch.rs:41:14
|
LL | /// Link to [derive@m]
- | ^^^^^^^^ help: to link to the macro, add an exclamation mark: `m!`
+ | ^^^^^^^^ this link resolved to a macro, which is not a derive macro
+ |
+help: to link to the macro, add an exclamation mark
|
- = note: this link resolved to a macro, which is not a derive macro
+LL | /// Link to [m!]
+ | --^
+
+error: unresolved link to `m`
+ --> $DIR/disambiguator-mismatch.rs:46:14
+ |
+LL | /// Link to [m()]
+ | ^^^ this link resolves to the macro `m`, which is not in the value namespace
+ |
+help: to link to the macro, add an exclamation mark
+ |
+LL | /// Link to [m!()]
+ | ^
error: incompatible link kind for `s`
- --> $DIR/disambiguator-mismatch.rs:44:14
+ --> $DIR/disambiguator-mismatch.rs:52:14
|
LL | /// Link to [const@s]
- | ^^^^^^^ help: to link to the static, prefix with `static@`: `static@s`
+ | ^^^^^^^ this link resolved to a static, which is not a constant
|
- = note: this link resolved to a static, which is not a constant
+help: to link to the static, prefix with `static@`
+ |
+LL | /// Link to [static@s]
+ | ^^^^^^^
error: incompatible link kind for `c`
- --> $DIR/disambiguator-mismatch.rs:49:14
+ --> $DIR/disambiguator-mismatch.rs:57:14
|
LL | /// Link to [static@c]
- | ^^^^^^^^ help: to link to the constant, prefix with `const@`: `const@c`
+ | ^^^^^^^^ this link resolved to a constant, which is not a static
+ |
+help: to link to the constant, prefix with `const@`
|
- = note: this link resolved to a constant, which is not a static
+LL | /// Link to [const@c]
+ | ^^^^^^
error: incompatible link kind for `c`
- --> $DIR/disambiguator-mismatch.rs:54:14
+ --> $DIR/disambiguator-mismatch.rs:62:14
|
LL | /// Link to [fn@c]
- | ^^^^ help: to link to the constant, prefix with `const@`: `const@c`
+ | ^^^^ this link resolved to a constant, which is not a function
|
- = note: this link resolved to a constant, which is not a function
+help: to link to the constant, prefix with `const@`
+ |
+LL | /// Link to [const@c]
+ | ^^^^^^
error: incompatible link kind for `c`
- --> $DIR/disambiguator-mismatch.rs:59:14
+ --> $DIR/disambiguator-mismatch.rs:67:14
|
LL | /// Link to [c()]
- | ^^^ help: to link to the constant, prefix with `const@`: `const@c`
+ | ^^^ this link resolved to a constant, which is not a function
+ |
+help: to link to the constant, prefix with `const@`
|
- = note: this link resolved to a constant, which is not a function
+LL | /// Link to [const@c]
+ | ^^^^^^--
error: incompatible link kind for `f`
- --> $DIR/disambiguator-mismatch.rs:64:14
+ --> $DIR/disambiguator-mismatch.rs:72:14
|
LL | /// Link to [const@f]
- | ^^^^^^^ help: to link to the function, add parentheses: `f()`
+ | ^^^^^^^ this link resolved to a function, which is not a constant
+ |
+help: to link to the function, add parentheses
|
- = note: this link resolved to a function, which is not a constant
+LL | /// Link to [f()]
+ | --^^
-error: aborting due to 11 previous errors
+error: aborting due to 12 previous errors
diff --git a/src/test/rustdoc-ui/intra-doc/errors.stderr b/src/test/rustdoc-ui/intra-doc/errors.stderr
index 061151720578b..87d107b9c573b 100644
--- a/src/test/rustdoc-ui/intra-doc/errors.stderr
+++ b/src/test/rustdoc-ui/intra-doc/errors.stderr
@@ -92,37 +92,45 @@ error: unresolved link to `Vec::into_iter`
--> $DIR/errors.rs:63:6
|
LL | /// [type@Vec::into_iter]
- | ^^^^^^^^^^^^^^^^^^^
- | |
- | this link resolves to the associated function `into_iter`, which is not in the type namespace
- | help: to link to the associated function, add parentheses: `Vec::into_iter()`
+ | ^^^^^^^^^^^^^^^^^^^ this link resolves to the associated function `into_iter`, which is not in the type namespace
+ |
+help: to link to the associated function, add parentheses
+ |
+LL | /// [Vec::into_iter()]
+ | -- ^^
error: unresolved link to `S`
--> $DIR/errors.rs:68:6
|
LL | /// [S!]
- | ^^
- | |
- | this link resolves to the struct `S`, which is not in the macro namespace
- | help: to link to the struct, prefix with `struct@`: `struct@S`
+ | ^^ this link resolves to the struct `S`, which is not in the macro namespace
+ |
+help: to link to the struct, prefix with `struct@`
+ |
+LL | /// [struct@S]
+ | ^^^^^^^--
error: unresolved link to `S::h`
--> $DIR/errors.rs:78:6
|
LL | /// [type@S::h]
- | ^^^^^^^^^
- | |
- | this link resolves to the associated function `h`, which is not in the type namespace
- | help: to link to the associated function, add parentheses: `S::h()`
+ | ^^^^^^^^^ this link resolves to the associated function `h`, which is not in the type namespace
+ |
+help: to link to the associated function, add parentheses
+ |
+LL | /// [S::h()]
+ | -- ^^
error: unresolved link to `T::g`
--> $DIR/errors.rs:86:6
|
LL | /// [type@T::g]
- | ^^^^^^^^^
- | |
- | this link resolves to the associated function `g`, which is not in the type namespace
- | help: to link to the associated function, add parentheses: `T::g()`
+ | ^^^^^^^^^ this link resolves to the associated function `g`, which is not in the type namespace
+ |
+help: to link to the associated function, add parentheses
+ |
+LL | /// [T::g()]
+ | -- ^^
error: unresolved link to `T::h`
--> $DIR/errors.rs:91:6
@@ -134,10 +142,12 @@ error: unresolved link to `m`
--> $DIR/errors.rs:98:6
|
LL | /// [m()]
- | ^^^
- | |
- | this link resolves to the macro `m`, which is not in the value namespace
- | help: to link to the macro, add an exclamation mark: `m!`
+ | ^^^ this link resolves to the macro `m`, which is not in the value namespace
+ |
+help: to link to the macro, add an exclamation mark
+ |
+LL | /// [m!()]
+ | ^
error: aborting due to 20 previous errors
diff --git a/src/test/rustdoc-ui/intra-doc/field-ice.stderr b/src/test/rustdoc-ui/intra-doc/field-ice.stderr
index ccb05b84a7282..3ab35d2df07b0 100644
--- a/src/test/rustdoc-ui/intra-doc/field-ice.stderr
+++ b/src/test/rustdoc-ui/intra-doc/field-ice.stderr
@@ -1,15 +1,18 @@
error: incompatible link kind for `Foo::bar`
- --> $DIR/field-ice.rs:5:6
+ --> $DIR/field-ice.rs:5:7
|
LL | /// [`Foo::bar()`]
- | ^^^^^^^^^^^^ help: to link to the field, remove the disambiguator: ``Foo::bar``
+ | ^^^^^^^^^^ this link resolved to a field, which is not a function
|
note: the lint level is defined here
--> $DIR/field-ice.rs:1:9
|
LL | #![deny(rustdoc::broken_intra_doc_links)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- = note: this link resolved to a field, which is not a function
+help: to link to the field, remove the disambiguator
+ |
+LL | /// [`Foo::bar`]
+ | ^^^^^^^^
error: aborting due to previous error
diff --git a/src/test/rustdoc-ui/intra-doc/incompatible-primitive-disambiguator.stderr b/src/test/rustdoc-ui/intra-doc/incompatible-primitive-disambiguator.stderr
index d4dcc493c8b6a..c2de5607ed64a 100644
--- a/src/test/rustdoc-ui/intra-doc/incompatible-primitive-disambiguator.stderr
+++ b/src/test/rustdoc-ui/intra-doc/incompatible-primitive-disambiguator.stderr
@@ -2,14 +2,17 @@ error: incompatible link kind for `u8::MIN`
--> $DIR/incompatible-primitive-disambiguator.rs:2:6
|
LL | //! [static@u8::MIN]
- | ^^^^^^^^^^^^^^ help: to link to the associated constant, prefix with `const@`: `const@u8::MIN`
+ | ^^^^^^^^^^^^^^ this link resolved to an associated constant, which is not a static
|
note: the lint level is defined here
--> $DIR/incompatible-primitive-disambiguator.rs:1:9
|
LL | #![deny(rustdoc::broken_intra_doc_links)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- = note: this link resolved to an associated constant, which is not a static
+help: to link to the associated constant, prefix with `const@`
+ |
+LL | //! [const@u8::MIN]
+ | ^^^^^^
error: aborting due to previous error
diff --git a/src/test/rustdoc-ui/intra-doc/prim-conflict.stderr b/src/test/rustdoc-ui/intra-doc/prim-conflict.stderr
index e4bd9fd4b8f1a..4dc1ce209007e 100644
--- a/src/test/rustdoc-ui/intra-doc/prim-conflict.stderr
+++ b/src/test/rustdoc-ui/intra-doc/prim-conflict.stderr
@@ -12,11 +12,11 @@ LL | #![deny(rustdoc::broken_intra_doc_links)]
help: to link to the module, prefix with `mod@`
|
LL | /// [mod@char]
- | ^^^^^^^^
+ | ^^^^
help: to link to the builtin type, prefix with `prim@`
|
LL | /// [prim@char]
- | ^^^^^^^^^
+ | ^^^^^
error: `char` is both a module and a builtin type
--> $DIR/prim-conflict.rs:10:6
@@ -27,27 +27,33 @@ LL | /// [type@char]
help: to link to the module, prefix with `mod@`
|
LL | /// [mod@char]
- | ^^^^^^^^
+ | ^^^^
help: to link to the builtin type, prefix with `prim@`
|
LL | /// [prim@char]
- | ^^^^^^^^^
+ | ^^^^^
error: incompatible link kind for `char`
--> $DIR/prim-conflict.rs:19:6
|
LL | /// [struct@char]
- | ^^^^^^^^^^^ help: to link to the module, prefix with `mod@`: `mod@char`
+ | ^^^^^^^^^^^ this link resolved to a module, which is not a struct
|
- = note: this link resolved to a module, which is not a struct
+help: to link to the module, prefix with `mod@`
+ |
+LL | /// [mod@char]
+ | ^^^^
error: incompatible link kind for `char`
--> $DIR/prim-conflict.rs:26:10
|
LL | //! [struct@char]
- | ^^^^^^^^^^^ help: to link to the builtin type, prefix with `prim@`: `prim@char`
+ | ^^^^^^^^^^^ this link resolved to a builtin type, which is not a struct
+ |
+help: to link to the builtin type, prefix with `prim@`
|
- = note: this link resolved to a builtin type, which is not a struct
+LL | //! [prim@char]
+ | ^^^^^
error: aborting due to 4 previous errors
diff --git a/src/test/rustdoc-ui/issue-74134.private.stderr b/src/test/rustdoc-ui/issue-74134.private.stderr
index 457987e207496..31d2dbe963758 100644
--- a/src/test/rustdoc-ui/issue-74134.private.stderr
+++ b/src/test/rustdoc-ui/issue-74134.private.stderr
@@ -1,8 +1,8 @@
warning: public documentation for `public_item` links to private item `PrivateType`
- --> $DIR/issue-74134.rs:19:10
+ --> $DIR/issue-74134.rs:19:11
|
LL | /// [`PrivateType`]
- | ^^^^^^^^^^^^^ this item is private
+ | ^^^^^^^^^^^ this item is private
|
= note: `#[warn(rustdoc::private_intra_doc_links)]` on by default
= note: this link resolves only because you passed `--document-private-items`, but will break without
diff --git a/src/test/rustdoc-ui/issue-74134.public.stderr b/src/test/rustdoc-ui/issue-74134.public.stderr
index 07aebc3541fe3..6a3173e3e0d6e 100644
--- a/src/test/rustdoc-ui/issue-74134.public.stderr
+++ b/src/test/rustdoc-ui/issue-74134.public.stderr
@@ -1,8 +1,8 @@
warning: public documentation for `public_item` links to private item `PrivateType`
- --> $DIR/issue-74134.rs:19:10
+ --> $DIR/issue-74134.rs:19:11
|
LL | /// [`PrivateType`]
- | ^^^^^^^^^^^^^ this item is private
+ | ^^^^^^^^^^^ this item is private
|
= note: `#[warn(rustdoc::private_intra_doc_links)]` on by default
= note: this link will resolve properly if you pass `--document-private-items`
diff --git a/src/test/ui/closures/2229_closure_analysis/issue-87426.rs b/src/test/ui/closures/2229_closure_analysis/issue-87426.rs
new file mode 100644
index 0000000000000..74506979a28c5
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/issue-87426.rs
@@ -0,0 +1,14 @@
+// run-pass
+// edition:2021
+
+pub fn foo() {
+ let ref_x_ck = 123;
+ let _y = || match ref_x_ck {
+ 2_000_000..=3_999_999 => { println!("A")}
+ _ => { println!("B")}
+ };
+}
+
+fn main() {
+ foo();
+}
diff --git a/src/test/ui/collections-const-new.rs b/src/test/ui/collections-const-new.rs
deleted file mode 100644
index 978f25f9a9344..0000000000000
--- a/src/test/ui/collections-const-new.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-// check-pass
-
-// Test several functions can be used for constants
-// 1. Vec::new()
-// 2. String::new()
-// 3. BTreeMap::new()
-// 4. BTreeSet::new()
-
-#![feature(const_btree_new)]
-
-const MY_VEC: Vec<usize> = Vec::new();
-
-const MY_STRING: String = String::new();
-
-use std::collections::{BTreeMap, BTreeSet};
-const MY_BTREEMAP: BTreeMap<u32, u32> = BTreeMap::new();
-
-const MY_BTREESET: BTreeSet<u32> = BTreeSet::new();
-
-fn main() {}
diff --git a/src/test/ui/consts/const-eval/issue-49296.rs b/src/test/ui/consts/const-eval/issue-49296.rs
index ba0885532f113..bb8113e53f9c1 100644
--- a/src/test/ui/consts/const-eval/issue-49296.rs
+++ b/src/test/ui/consts/const-eval/issue-49296.rs
@@ -1,8 +1,10 @@
// issue-49296: Unsafe shenigans in constants can result in missing errors
#![feature(const_fn_trait_bound)]
+#![feature(const_trait_bound_opt_out)]
+#![allow(incomplete_features)]
-const unsafe fn transmute<T: Copy, U: Copy>(t: T) -> U {
+const unsafe fn transmute<T: ?const Copy, U: ?const Copy>(t: T) -> U {
#[repr(C)]
union Transmute<T: Copy, U: Copy> {
from: T,
diff --git a/src/test/ui/consts/const-eval/issue-49296.stderr b/src/test/ui/consts/const-eval/issue-49296.stderr
index e87ef160b8278..28fdcb7c48637 100644
--- a/src/test/ui/consts/const-eval/issue-49296.stderr
+++ b/src/test/ui/consts/const-eval/issue-49296.stderr
@@ -1,5 +1,5 @@
error[E0080]: evaluation of constant value failed
- --> $DIR/issue-49296.rs:18:16
+ --> $DIR/issue-49296.rs:20:16
|
LL | const X: u64 = *wat(42);
| ^^^^^^^^ pointer to alloc2 was dereferenced after this allocation got freed
diff --git a/src/test/ui/generic-associated-types/projection-bound-cycle-generic.stderr b/src/test/ui/generic-associated-types/projection-bound-cycle-generic.stderr
index d5e9caf9ecd4e..1900ac040039b 100644
--- a/src/test/ui/generic-associated-types/projection-bound-cycle-generic.stderr
+++ b/src/test/ui/generic-associated-types/projection-bound-cycle-generic.stderr
@@ -1,8 +1,8 @@
error[E0275]: overflow evaluating the requirement `<T as Foo>::Item: Sized`
--> $DIR/projection-bound-cycle-generic.rs:44:5
|
-LL | struct OnlySized<T> where T: Sized { f: T }
- | - required by this bound in `OnlySized`
+LL | type Item: Sized where <Self as Foo>::Item: Sized;
+ | ----- required by this bound in `Foo::Item`
...
LL | type Assoc = OnlySized<<T as Foo>::Item>;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/test/ui/generic-associated-types/projection-bound-cycle.stderr b/src/test/ui/generic-associated-types/projection-bound-cycle.stderr
index fac62fef1ecff..7d560cb32135c 100644
--- a/src/test/ui/generic-associated-types/projection-bound-cycle.stderr
+++ b/src/test/ui/generic-associated-types/projection-bound-cycle.stderr
@@ -1,8 +1,8 @@
error[E0275]: overflow evaluating the requirement `<T as Foo>::Item: Sized`
--> $DIR/projection-bound-cycle.rs:46:5
|
-LL | struct OnlySized<T> where T: Sized { f: T }
- | - required by this bound in `OnlySized`
+LL | type Item: Sized where <Self as Foo>::Item: Sized;
+ | ----- required by this bound in `Foo::Item`
...
LL | type Assoc = OnlySized<<T as Foo>::Item>;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/test/ui/hygiene/auxiliary/intercrate.rs b/src/test/ui/hygiene/auxiliary/intercrate.rs
index 10d399ba54e71..0685358851edd 100644
--- a/src/test/ui/hygiene/auxiliary/intercrate.rs
+++ b/src/test/ui/hygiene/auxiliary/intercrate.rs
@@ -5,7 +5,7 @@ pub mod foo {
mod bar {
fn f() -> u32 { 1 }
pub macro m() {
- f();
+ f()
}
}
}
diff --git a/src/test/ui/hygiene/hygienic-label-1.rs b/src/test/ui/hygiene/hygienic-label-1.rs
index 66361eec21a52..a06d9255ab5b0 100644
--- a/src/test/ui/hygiene/hygienic-label-1.rs
+++ b/src/test/ui/hygiene/hygienic-label-1.rs
@@ -3,5 +3,5 @@ macro_rules! foo {
}
pub fn main() {
- 'x: loop { foo!() }
+ 'x: loop { foo!(); }
}
diff --git a/src/test/ui/hygiene/hygienic-label-1.stderr b/src/test/ui/hygiene/hygienic-label-1.stderr
index 97a7240b9069b..c1ed861836c1c 100644
--- a/src/test/ui/hygiene/hygienic-label-1.stderr
+++ b/src/test/ui/hygiene/hygienic-label-1.stderr
@@ -4,8 +4,8 @@ error[E0426]: use of undeclared label `'x`
LL | () => { break 'x; }
| ^^ undeclared label `'x`
...
-LL | 'x: loop { foo!() }
- | ------ in this macro invocation
+LL | 'x: loop { foo!(); }
+ | ------- in this macro invocation
|
= note: this error originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/src/test/ui/hygiene/hygienic-label-3.rs b/src/test/ui/hygiene/hygienic-label-3.rs
index a81eb84225970..ab0559e1b6a83 100644
--- a/src/test/ui/hygiene/hygienic-label-3.rs
+++ b/src/test/ui/hygiene/hygienic-label-3.rs
@@ -4,6 +4,6 @@ macro_rules! foo {
pub fn main() {
'x: for _ in 0..1 {
- foo!()
+ foo!();
};
}
diff --git a/src/test/ui/hygiene/hygienic-label-3.stderr b/src/test/ui/hygiene/hygienic-label-3.stderr
index 52840049f825a..29d1b67e09f9b 100644
--- a/src/test/ui/hygiene/hygienic-label-3.stderr
+++ b/src/test/ui/hygiene/hygienic-label-3.stderr
@@ -4,8 +4,8 @@ error[E0426]: use of undeclared label `'x`
LL | () => { break 'x; }
| ^^ undeclared label `'x`
...
-LL | foo!()
- | ------ in this macro invocation
+LL | foo!();
+ | ------- in this macro invocation
|
= note: this error originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/src/test/ui/lint/semicolon-in-expressions-from-macros/allow-semicolon-in-expressions-from-macros.rs b/src/test/ui/lint/semicolon-in-expressions-from-macros/allow-semicolon-in-expressions-from-macros.rs
deleted file mode 100644
index 6f9e6ec0a57ff..0000000000000
--- a/src/test/ui/lint/semicolon-in-expressions-from-macros/allow-semicolon-in-expressions-from-macros.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-// check-pass
-// Ensure that trailing semicolons are allowed by default
-
-macro_rules! foo {
- () => {
- true;
- }
-}
-
-fn main() {
- let val = match true {
- true => false,
- _ => foo!()
- };
-}
diff --git a/src/test/ui/lint/semicolon-in-expressions-from-macros/auxiliary/foreign-crate.rs b/src/test/ui/lint/semicolon-in-expressions-from-macros/auxiliary/foreign-crate.rs
new file mode 100644
index 0000000000000..781391cc574a9
--- /dev/null
+++ b/src/test/ui/lint/semicolon-in-expressions-from-macros/auxiliary/foreign-crate.rs
@@ -0,0 +1,4 @@
+#[macro_export]
+macro_rules! my_macro {
+ () => { true; }
+}
diff --git a/src/test/ui/lint/semicolon-in-expressions-from-macros/foreign-crate.rs b/src/test/ui/lint/semicolon-in-expressions-from-macros/foreign-crate.rs
new file mode 100644
index 0000000000000..374506366f802
--- /dev/null
+++ b/src/test/ui/lint/semicolon-in-expressions-from-macros/foreign-crate.rs
@@ -0,0 +1,9 @@
+// aux-build:foreign-crate.rs
+// check-pass
+
+extern crate foreign_crate;
+
+// Test that we do not lint for a macro in a foreign crate
+fn main() {
+ let _ = foreign_crate::my_macro!();
+}
diff --git a/src/test/ui/lint/semicolon-in-expressions-from-macros/warn-semicolon-in-expressions-from-macros.rs b/src/test/ui/lint/semicolon-in-expressions-from-macros/warn-semicolon-in-expressions-from-macros.rs
new file mode 100644
index 0000000000000..2c63311e65978
--- /dev/null
+++ b/src/test/ui/lint/semicolon-in-expressions-from-macros/warn-semicolon-in-expressions-from-macros.rs
@@ -0,0 +1,16 @@
+// check-pass
+// Ensure that trailing semicolons cause warnings by default
+
+macro_rules! foo {
+ () => {
+ true; //~ WARN trailing semicolon in macro
+ //~| WARN this was previously
+ }
+}
+
+fn main() {
+ let _val = match true {
+ true => false,
+ _ => foo!()
+ };
+}
diff --git a/src/test/ui/lint/semicolon-in-expressions-from-macros/warn-semicolon-in-expressions-from-macros.stderr b/src/test/ui/lint/semicolon-in-expressions-from-macros/warn-semicolon-in-expressions-from-macros.stderr
new file mode 100644
index 0000000000000..d770a8c8f36e6
--- /dev/null
+++ b/src/test/ui/lint/semicolon-in-expressions-from-macros/warn-semicolon-in-expressions-from-macros.stderr
@@ -0,0 +1,16 @@
+warning: trailing semicolon in macro used in expression position
+ --> $DIR/warn-semicolon-in-expressions-from-macros.rs:6:13
+ |
+LL | true;
+ | ^
+...
+LL | _ => foo!()
+ | ------ in this macro invocation
+ |
+ = note: `#[warn(semicolon_in_expressions_from_macros)]` on by default
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #79813 <https://github.com/rust-lang/rust/issues/79813>
+ = note: this warning originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+warning: 1 warning emitted
+
diff --git a/src/test/ui/macros/macro-context.rs b/src/test/ui/macros/macro-context.rs
index 13e179578ad01..d09fdf118e6f4 100644
--- a/src/test/ui/macros/macro-context.rs
+++ b/src/test/ui/macros/macro-context.rs
@@ -6,6 +6,8 @@ macro_rules! m {
//~| ERROR macro expansion ignores token `;`
//~| ERROR cannot find type `i` in this scope
//~| ERROR cannot find value `i` in this scope
+ //~| WARN trailing semicolon in macro
+ //~| WARN this was previously
}
fn main() {
diff --git a/src/test/ui/macros/macro-context.stderr b/src/test/ui/macros/macro-context.stderr
index 5ed73b7fb93a3..3b8a6f1749158 100644
--- a/src/test/ui/macros/macro-context.stderr
+++ b/src/test/ui/macros/macro-context.stderr
@@ -64,7 +64,21 @@ LL | let i = m!();
|
= note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
-error: aborting due to 6 previous errors
+warning: trailing semicolon in macro used in expression position
+ --> $DIR/macro-context.rs:3:15
+ |
+LL | () => ( i ; typeof );
+ | ^
+...
+LL | let i = m!();
+ | ---- in this macro invocation
+ |
+ = note: `#[warn(semicolon_in_expressions_from_macros)]` on by default
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #79813 <https://github.com/rust-lang/rust/issues/79813>
+ = note: this warning originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 6 previous errors; 1 warning emitted
Some errors have detailed explanations: E0412, E0425.
For more information about an error, try `rustc --explain E0412`.
diff --git a/src/test/ui/macros/macro-in-expression-context.fixed b/src/test/ui/macros/macro-in-expression-context.fixed
index df36db0f49e72..f22caf2793fd5 100644
--- a/src/test/ui/macros/macro-in-expression-context.fixed
+++ b/src/test/ui/macros/macro-in-expression-context.fixed
@@ -3,6 +3,12 @@
macro_rules! foo {
() => {
assert_eq!("A", "A");
+ //~^ WARN trailing semicolon in macro
+ //~| WARN this was previously
+ //~| NOTE macro invocations at the end of a block
+ //~| NOTE to ignore the value produced by the macro
+ //~| NOTE for more information
+ //~| NOTE `#[warn(semicolon_in_expressions_from_macros)]` on by default
assert_eq!("B", "B");
}
//~^^ ERROR macro expansion ignores token `assert_eq` and any following
@@ -12,4 +18,10 @@ macro_rules! foo {
fn main() {
foo!();
//~^ NOTE caused by the macro expansion here
+ //~| NOTE in this expansion
+ //~| NOTE in this expansion
+ //~| NOTE in this expansion
+ //~| NOTE in this expansion
+ //~| NOTE in this expansion
+ //~| NOTE in this expansion
}
diff --git a/src/test/ui/macros/macro-in-expression-context.rs b/src/test/ui/macros/macro-in-expression-context.rs
index b3f5e568967e8..1a056e582ff47 100644
--- a/src/test/ui/macros/macro-in-expression-context.rs
+++ b/src/test/ui/macros/macro-in-expression-context.rs
@@ -3,6 +3,12 @@
macro_rules! foo {
() => {
assert_eq!("A", "A");
+ //~^ WARN trailing semicolon in macro
+ //~| WARN this was previously
+ //~| NOTE macro invocations at the end of a block
+ //~| NOTE to ignore the value produced by the macro
+ //~| NOTE for more information
+ //~| NOTE `#[warn(semicolon_in_expressions_from_macros)]` on by default
assert_eq!("B", "B");
}
//~^^ ERROR macro expansion ignores token `assert_eq` and any following
@@ -12,4 +18,10 @@ macro_rules! foo {
fn main() {
foo!()
//~^ NOTE caused by the macro expansion here
+ //~| NOTE in this expansion
+ //~| NOTE in this expansion
+ //~| NOTE in this expansion
+ //~| NOTE in this expansion
+ //~| NOTE in this expansion
+ //~| NOTE in this expansion
}
diff --git a/src/test/ui/macros/macro-in-expression-context.stderr b/src/test/ui/macros/macro-in-expression-context.stderr
index d27d6fbaef7a6..1840babd61dc2 100644
--- a/src/test/ui/macros/macro-in-expression-context.stderr
+++ b/src/test/ui/macros/macro-in-expression-context.stderr
@@ -1,5 +1,5 @@
error: macro expansion ignores token `assert_eq` and any following
- --> $DIR/macro-in-expression-context.rs:6:9
+ --> $DIR/macro-in-expression-context.rs:12:9
|
LL | assert_eq!("B", "B");
| ^^^^^^^^^
@@ -11,5 +11,21 @@ LL | foo!()
|
= note: the usage of `foo!` is likely invalid in expression context
-error: aborting due to previous error
+warning: trailing semicolon in macro used in expression position
+ --> $DIR/macro-in-expression-context.rs:5:29
+ |
+LL | assert_eq!("A", "A");
+ | ^
+...
+LL | foo!()
+ | ------ in this macro invocation
+ |
+ = note: `#[warn(semicolon_in_expressions_from_macros)]` on by default
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #79813 <https://github.com/rust-lang/rust/issues/79813>
+ = note: macro invocations at the end of a block are treated as expressions
+ = note: to ignore the value produced by the macro, add a semicolon after the invocation of `foo`
+ = note: this warning originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to previous error; 1 warning emitted
diff --git a/src/test/ui/proc-macro/nested-nonterminal-tokens.rs b/src/test/ui/proc-macro/nested-nonterminal-tokens.rs
index 2f5af10a40ac2..04d34e21cdc74 100644
--- a/src/test/ui/proc-macro/nested-nonterminal-tokens.rs
+++ b/src/test/ui/proc-macro/nested-nonterminal-tokens.rs
@@ -17,7 +17,7 @@ macro_rules! wrap {
(first, $e:expr) => { wrap!(second, $e + 1) };
(second, $e:expr) => { wrap!(third, $e + 2) };
(third, $e:expr) => {
- print_bang!($e + 3);
+ print_bang!($e + 3)
};
}
diff --git a/src/test/ui/rfc-2632-const-trait-impl/assoc-type.rs b/src/test/ui/rfc-2632-const-trait-impl/assoc-type.rs
index 4a1bd5da98b8a..1dbd000afd73e 100644
--- a/src/test/ui/rfc-2632-const-trait-impl/assoc-type.rs
+++ b/src/test/ui/rfc-2632-const-trait-impl/assoc-type.rs
@@ -1,9 +1,7 @@
-// ignore-test
-
-// FIXME: This test should fail since, within a const impl of `Foo`, the bound on `Foo::Bar` should
-// require a const impl of `Add` for the associated type.
-
+// FIXME(fee1-dead): this should have a better error message
#![feature(const_trait_impl)]
+#![feature(const_trait_bound_opt_out)]
+#![allow(incomplete_features)]
struct NonConstAdd(i32);
@@ -21,6 +19,15 @@ trait Foo {
impl const Foo for NonConstAdd {
type Bar = NonConstAdd;
+ //~^ ERROR
+}
+
+trait Baz {
+ type Qux: ?const std::ops::Add;
+}
+
+impl const Baz for NonConstAdd {
+ type Qux = NonConstAdd; // OK
}
fn main() {}
diff --git a/src/test/ui/rfc-2632-const-trait-impl/assoc-type.stderr b/src/test/ui/rfc-2632-const-trait-impl/assoc-type.stderr
new file mode 100644
index 0000000000000..0cbeb71d23538
--- /dev/null
+++ b/src/test/ui/rfc-2632-const-trait-impl/assoc-type.stderr
@@ -0,0 +1,18 @@
+error[E0277]: cannot add `NonConstAdd` to `NonConstAdd`
+ --> $DIR/assoc-type.rs:21:5
+ |
+LL | type Bar: std::ops::Add;
+ | ------------- required by this bound in `Foo::Bar`
+...
+LL | type Bar = NonConstAdd;
+ | ^^^^^^^^^^^^^^^^^^^^^^^ no implementation for `NonConstAdd + NonConstAdd`
+ |
+ = help: the trait `Add` is not implemented for `NonConstAdd`
+help: consider introducing a `where` bound, but there might be an alternative better way to express this requirement
+ |
+LL | impl const Foo for NonConstAdd where NonConstAdd: Add {
+ | ^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/src/test/ui/rfc-2632-const-trait-impl/call-generic-method-nonconst.rs b/src/test/ui/rfc-2632-const-trait-impl/call-generic-method-nonconst.rs
index 087f8fbdcd1ea..8343974f8c7e7 100644
--- a/src/test/ui/rfc-2632-const-trait-impl/call-generic-method-nonconst.rs
+++ b/src/test/ui/rfc-2632-const-trait-impl/call-generic-method-nonconst.rs
@@ -1,7 +1,5 @@
-// FIXME(jschievink): this is not rejected correctly (only when the non-const impl is actually used)
-// ignore-test
-
#![feature(const_trait_impl)]
+#![feature(const_fn_trait_bound)]
struct S;
diff --git a/src/test/ui/rfc-2632-const-trait-impl/call-generic-method-nonconst.stderr b/src/test/ui/rfc-2632-const-trait-impl/call-generic-method-nonconst.stderr
new file mode 100644
index 0000000000000..75c7cab362147
--- /dev/null
+++ b/src/test/ui/rfc-2632-const-trait-impl/call-generic-method-nonconst.stderr
@@ -0,0 +1,14 @@
+error[E0277]: can't compare `S` with `S`
+ --> $DIR/call-generic-method-nonconst.rs:19:34
+ |
+LL | const fn equals_self<T: PartialEq>(t: &T) -> bool {
+ | --------- required by this bound in `equals_self`
+...
+LL | pub const EQ: bool = equals_self(&S);
+ | ^^ no implementation for `S == S`
+ |
+ = help: the trait `PartialEq` is not implemented for `S`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/src/test/ui/type-alias-impl-trait/issue-87455-static-lifetime-ice.rs b/src/test/ui/type-alias-impl-trait/issue-87455-static-lifetime-ice.rs
new file mode 100644
index 0000000000000..80a74eb63a83e
--- /dev/null
+++ b/src/test/ui/type-alias-impl-trait/issue-87455-static-lifetime-ice.rs
@@ -0,0 +1,73 @@
+// check-pass
+
+use std::error::Error as StdError;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+pub trait Stream {
+ type Item;
+ fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>>;
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ (0, None)
+ }
+}
+
+pub trait TryStream: Stream {
+ type Ok;
+ type Error;
+
+ fn try_poll_next(
+ self: Pin<&mut Self>,
+ cx: &mut Context<'_>,
+ ) -> Poll<Option<Result<Self::Ok, Self::Error>>>;
+}
+
+impl<S, T, E> TryStream for S
+where
+ S: ?Sized + Stream<Item = Result<T, E>>,
+{
+ type Ok = T;
+ type Error = E;
+
+ fn try_poll_next(
+ self: Pin<&mut Self>,
+ cx: &mut Context<'_>,
+ ) -> Poll<Option<Result<Self::Ok, Self::Error>>> {
+ self.poll_next(cx)
+ }
+}
+
+pub trait ServerSentEvent: Sized + Send + Sync + 'static {}
+
+impl<T: Send + Sync + 'static> ServerSentEvent for T {}
+
+struct SseKeepAlive<S> {
+ event_stream: S,
+}
+
+struct SseComment<T>(T);
+
+impl<S> Stream for SseKeepAlive<S>
+where
+ S: TryStream + Send + 'static,
+ S::Ok: ServerSentEvent,
+ S::Error: StdError + Send + Sync + 'static,
+{
+ type Item = Result<SseComment<&'static str>, ()>;
+ fn poll_next(self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Option<Self::Item>> {
+ unimplemented!()
+ }
+}
+
+pub fn keep<S>(
+ event_stream: S,
+) -> impl TryStream<Ok = impl ServerSentEvent + Send + 'static, Error = ()> + Send + 'static
+where
+ S: TryStream + Send + 'static,
+ S::Ok: ServerSentEvent + Send,
+ S::Error: StdError + Send + Sync + 'static,
+{
+ SseKeepAlive { event_stream }
+}
+
+fn main() {}
diff --git a/src/tools/clippy/clippy_lints/src/future_not_send.rs b/src/tools/clippy/clippy_lints/src/future_not_send.rs
index 515b8887453b9..29bead8584e87 100644
--- a/src/tools/clippy/clippy_lints/src/future_not_send.rs
+++ b/src/tools/clippy/clippy_lints/src/future_not_send.rs
@@ -94,7 +94,7 @@ impl<'tcx> LateLintPass<'tcx> for FutureNotSend {
cx.tcx.infer_ctxt().enter(|infcx| {
for FulfillmentError { obligation, .. } in send_errors {
infcx.maybe_note_obligation_cause_for_async_await(db, &obligation);
- if let Trait(trait_pred, _) = obligation.predicate.kind().skip_binder() {
+ if let Trait(trait_pred) = obligation.predicate.kind().skip_binder() {
db.note(&format!(
"`{}` doesn't implement `{}`",
trait_pred.self_ty(),
diff --git a/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs b/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs
index 57fd03f4e12a6..6e247fb99ea3d 100644
--- a/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs
+++ b/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs
@@ -120,7 +120,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
.filter_map(|obligation| {
// Note that we do not want to deal with qualified predicates here.
match obligation.predicate.kind().no_bound_vars() {
- Some(ty::PredicateKind::Trait(pred, _)) if pred.def_id() != sized_trait => Some(pred),
+ Some(ty::PredicateKind::Trait(pred)) if pred.def_id() != sized_trait => Some(pred),
_ => None,
}
})
diff --git a/src/tools/clippy/clippy_lints/src/unit_return_expecting_ord.rs b/src/tools/clippy/clippy_lints/src/unit_return_expecting_ord.rs
index 1c420a5042721..76b258ee62de9 100644
--- a/src/tools/clippy/clippy_lints/src/unit_return_expecting_ord.rs
+++ b/src/tools/clippy/clippy_lints/src/unit_return_expecting_ord.rs
@@ -43,7 +43,7 @@ fn get_trait_predicates_for_trait_id<'tcx>(
let mut preds = Vec::new();
for (pred, _) in generics.predicates {
if_chain! {
- if let PredicateKind::Trait(poly_trait_pred, _) = pred.kind().skip_binder();
+ if let PredicateKind::Trait(poly_trait_pred) = pred.kind().skip_binder();
let trait_pred = cx.tcx.erase_late_bound_regions(pred.kind().rebind(poly_trait_pred));
if let Some(trait_def_id) = trait_id;
if trait_def_id == trait_pred.trait_ref.def_id;
diff --git a/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs b/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs
index 0e6ead675c247..dee9d487c78ea 100644
--- a/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs
+++ b/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs
@@ -36,7 +36,7 @@ pub fn is_min_const_fn(tcx: TyCtxt<'tcx>, body: &'a Body<'tcx>, msrv: Option<&Ru
ty::PredicateKind::ObjectSafe(_) => panic!("object safe predicate on function: {:#?}", predicate),
ty::PredicateKind::ClosureKind(..) => panic!("closure kind predicate on function: {:#?}", predicate),
ty::PredicateKind::Subtype(_) => panic!("subtype predicate on function: {:#?}", predicate),
- ty::PredicateKind::Trait(pred, _) => {
+ ty::PredicateKind::Trait(pred) => {
if Some(pred.def_id()) == tcx.lang_items().sized_trait() {
continue;
}
diff --git a/src/tools/clippy/clippy_utils/src/ty.rs b/src/tools/clippy/clippy_utils/src/ty.rs
index e914dc1c222f6..7988484bccccc 100644
--- a/src/tools/clippy/clippy_utils/src/ty.rs
+++ b/src/tools/clippy/clippy_utils/src/ty.rs
@@ -157,7 +157,7 @@ pub fn is_must_use_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
ty::Tuple(substs) => substs.types().any(|ty| is_must_use_ty(cx, ty)),
ty::Opaque(ref def_id, _) => {
for (predicate, _) in cx.tcx.explicit_item_bounds(*def_id) {
- if let ty::PredicateKind::Trait(trait_predicate, _) = predicate.kind().skip_binder() {
+ if let ty::PredicateKind::Trait(trait_predicate) = predicate.kind().skip_binder() {
if must_use_attr(cx.tcx.get_attrs(trait_predicate.trait_ref.def_id)).is_some() {
return true;
}
diff --git a/src/tools/clippy/tests/ui/needless_borrow_pat.rs b/src/tools/clippy/tests/ui/needless_borrow_pat.rs
index f0926220755a2..7a8137778b446 100644
--- a/src/tools/clippy/tests/ui/needless_borrow_pat.rs
+++ b/src/tools/clippy/tests/ui/needless_borrow_pat.rs
@@ -7,7 +7,7 @@
fn f1(_: &str) {}
macro_rules! m1 {
($e:expr) => {
- f1($e);
+ f1($e)
};
}
macro_rules! m3 {
diff --git a/src/tools/clippy/tests/ui/ref_binding_to_reference.rs b/src/tools/clippy/tests/ui/ref_binding_to_reference.rs
index c7235e1c22105..cd6db8ddc8864 100644
--- a/src/tools/clippy/tests/ui/ref_binding_to_reference.rs
+++ b/src/tools/clippy/tests/ui/ref_binding_to_reference.rs
@@ -7,7 +7,7 @@
fn f1(_: &str) {}
macro_rules! m2 {
($e:expr) => {
- f1(*$e);
+ f1(*$e)
};
}
macro_rules! m3 {