Auto merge of #139938 - matthiaskrgr:rollup-19ddpus, r=matthiaskrgr
Rollup of 8 pull requests Successful merges: - #139084 (hygiene: Rename semi-transparent to semi-opaque) - #139236 (Use a session counter to make anon dep nodes unique) - #139650 (Fix `register_group_alias` for tools) - #139770 (Rename `LifetimeName` as `LifetimeKind`.) - #139846 (Remove `kw::Empty` uses in rustdoc) - #139891 (Include optional dso_local marker for functions in `enum-match.rs`) - #139908 (parser: Remove old diagnostic notes for type ascription syntax) - #139917 (fix for multiple `#[repr(align(N))]` on functions) Failed merges: - #139615 (Remove `name_or_empty`) r? `@ghost` `@rustbot` modify labels: rollup
This commit is contained in:
bors
commit
79a272c640
66 changed files with 265 additions and 302 deletions
|
|
@ -1767,21 +1767,21 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
|
|||
) -> &'hir hir::Lifetime {
|
||||
let res = self.resolver.get_lifetime_res(id).unwrap_or(LifetimeRes::Error);
|
||||
let res = match res {
|
||||
LifetimeRes::Param { param, .. } => hir::LifetimeName::Param(param),
|
||||
LifetimeRes::Param { param, .. } => hir::LifetimeKind::Param(param),
|
||||
LifetimeRes::Fresh { param, .. } => {
|
||||
debug_assert_eq!(ident.name, kw::UnderscoreLifetime);
|
||||
let param = self.local_def_id(param);
|
||||
hir::LifetimeName::Param(param)
|
||||
hir::LifetimeKind::Param(param)
|
||||
}
|
||||
LifetimeRes::Infer => {
|
||||
debug_assert_eq!(ident.name, kw::UnderscoreLifetime);
|
||||
hir::LifetimeName::Infer
|
||||
hir::LifetimeKind::Infer
|
||||
}
|
||||
LifetimeRes::Static { .. } => {
|
||||
debug_assert!(matches!(ident.name, kw::StaticLifetime | kw::UnderscoreLifetime));
|
||||
hir::LifetimeName::Static
|
||||
hir::LifetimeKind::Static
|
||||
}
|
||||
LifetimeRes::Error => hir::LifetimeName::Error,
|
||||
LifetimeRes::Error => hir::LifetimeKind::Error,
|
||||
LifetimeRes::ElidedAnchor { .. } => {
|
||||
panic!("Unexpected `ElidedAnchar` {:?} at {:?}", ident, ident.span);
|
||||
}
|
||||
|
|
@ -2388,7 +2388,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
|
|||
let r = hir::Lifetime::new(
|
||||
self.next_id(),
|
||||
Ident::new(kw::UnderscoreLifetime, self.lower_span(span)),
|
||||
hir::LifetimeName::ImplicitObjectLifetimeDefault,
|
||||
hir::LifetimeKind::ImplicitObjectLifetimeDefault,
|
||||
IsAnonInPath::No,
|
||||
);
|
||||
debug!("elided_dyn_bound: r={:?}", r);
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ impl SingleAttributeParser for TransparencyParser {
|
|||
fn convert(cx: &AcceptContext<'_>, args: &ArgParser<'_>) -> Option<AttributeKind> {
|
||||
match args.name_value().and_then(|nv| nv.value_as_str()) {
|
||||
Some(sym::transparent) => Some(Transparency::Transparent),
|
||||
Some(sym::semitransparent) => Some(Transparency::SemiTransparent),
|
||||
Some(sym::semiopaque | sym::semitransparent) => Some(Transparency::SemiOpaque),
|
||||
Some(sym::opaque) => Some(Transparency::Opaque),
|
||||
Some(other) => {
|
||||
cx.dcx().span_err(cx.attr_span, format!("unknown macro transparency: `{other}`"));
|
||||
|
|
|
|||
|
|
@ -888,7 +888,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
|
|||
// Skip `async` desugaring `impl Future`.
|
||||
}
|
||||
if let TyKind::TraitObject(_, lt) = alias_ty.kind {
|
||||
if lt.res == hir::LifetimeName::ImplicitObjectLifetimeDefault {
|
||||
if lt.kind == hir::LifetimeKind::ImplicitObjectLifetimeDefault {
|
||||
spans_suggs.push((lt.ident.span.shrink_to_hi(), " + 'a".to_string()));
|
||||
} else {
|
||||
spans_suggs.push((lt.ident.span, "'a".to_string()));
|
||||
|
|
|
|||
|
|
@ -114,7 +114,8 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
|
|||
AttributeKind::Repr(reprs) => {
|
||||
codegen_fn_attrs.alignment = reprs
|
||||
.iter()
|
||||
.find_map(|(r, _)| if let ReprAlign(x) = r { Some(*x) } else { None });
|
||||
.filter_map(|(r, _)| if let ReprAlign(x) = r { Some(*x) } else { None })
|
||||
.max();
|
||||
}
|
||||
|
||||
_ => {}
|
||||
|
|
|
|||
|
|
@ -767,7 +767,7 @@ pub static BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
|
|||
),
|
||||
rustc_attr!(
|
||||
rustc_macro_transparency, Normal,
|
||||
template!(NameValueStr: "transparent|semitransparent|opaque"), ErrorFollowing,
|
||||
template!(NameValueStr: "transparent|semiopaque|opaque"), ErrorFollowing,
|
||||
EncodeCrossCrate::Yes, "used internally for testing macro hygiene",
|
||||
),
|
||||
rustc_attr!(
|
||||
|
|
|
|||
|
|
@ -42,7 +42,7 @@ pub enum IsAnonInPath {
|
|||
}
|
||||
|
||||
/// A lifetime. The valid field combinations are non-obvious. The following
|
||||
/// example shows some of them. See also the comments on `LifetimeName`.
|
||||
/// example shows some of them. See also the comments on `LifetimeKind`.
|
||||
/// ```
|
||||
/// #[repr(C)]
|
||||
/// struct S<'a>(&'a u32); // res=Param, name='a, IsAnonInPath::No
|
||||
|
|
@ -84,7 +84,7 @@ pub struct Lifetime {
|
|||
pub ident: Ident,
|
||||
|
||||
/// Semantics of this lifetime.
|
||||
pub res: LifetimeName,
|
||||
pub kind: LifetimeKind,
|
||||
|
||||
/// Is the lifetime anonymous and in a path? Used only for error
|
||||
/// suggestions. See `Lifetime::suggestion` for example use.
|
||||
|
|
@ -130,7 +130,7 @@ impl ParamName {
|
|||
}
|
||||
|
||||
#[derive(Debug, Copy, Clone, PartialEq, Eq, HashStable_Generic)]
|
||||
pub enum LifetimeName {
|
||||
pub enum LifetimeKind {
|
||||
/// User-given names or fresh (synthetic) names.
|
||||
Param(LocalDefId),
|
||||
|
||||
|
|
@ -160,16 +160,16 @@ pub enum LifetimeName {
|
|||
Static,
|
||||
}
|
||||
|
||||
impl LifetimeName {
|
||||
impl LifetimeKind {
|
||||
fn is_elided(&self) -> bool {
|
||||
match self {
|
||||
LifetimeName::ImplicitObjectLifetimeDefault | LifetimeName::Infer => true,
|
||||
LifetimeKind::ImplicitObjectLifetimeDefault | LifetimeKind::Infer => true,
|
||||
|
||||
// It might seem surprising that `Fresh` counts as not *elided*
|
||||
// -- but this is because, as far as the code in the compiler is
|
||||
// concerned -- `Fresh` variants act equivalently to "some fresh name".
|
||||
// They correspond to early-bound regions on an impl, in other words.
|
||||
LifetimeName::Error | LifetimeName::Param(..) | LifetimeName::Static => false,
|
||||
LifetimeKind::Error | LifetimeKind::Param(..) | LifetimeKind::Static => false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -184,10 +184,10 @@ impl Lifetime {
|
|||
pub fn new(
|
||||
hir_id: HirId,
|
||||
ident: Ident,
|
||||
res: LifetimeName,
|
||||
kind: LifetimeKind,
|
||||
is_anon_in_path: IsAnonInPath,
|
||||
) -> Lifetime {
|
||||
let lifetime = Lifetime { hir_id, ident, res, is_anon_in_path };
|
||||
let lifetime = Lifetime { hir_id, ident, kind, is_anon_in_path };
|
||||
|
||||
// Sanity check: elided lifetimes form a strict subset of anonymous lifetimes.
|
||||
#[cfg(debug_assertions)]
|
||||
|
|
@ -202,7 +202,7 @@ impl Lifetime {
|
|||
}
|
||||
|
||||
pub fn is_elided(&self) -> bool {
|
||||
self.res.is_elided()
|
||||
self.kind.is_elided()
|
||||
}
|
||||
|
||||
pub fn is_anonymous(&self) -> bool {
|
||||
|
|
@ -1014,7 +1014,7 @@ pub struct WhereRegionPredicate<'hir> {
|
|||
impl<'hir> WhereRegionPredicate<'hir> {
|
||||
/// Returns `true` if `param_def_id` matches the `lifetime` of this predicate.
|
||||
fn is_param_bound(&self, param_def_id: LocalDefId) -> bool {
|
||||
self.lifetime.res == LifetimeName::Param(param_def_id)
|
||||
self.lifetime.kind == LifetimeKind::Param(param_def_id)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -57,7 +57,7 @@ fn trait_object_roundtrips_impl(syntax: TraitObjectSyntax) {
|
|||
Lifetime {
|
||||
hir_id: HirId::INVALID,
|
||||
ident: Ident::new(sym::name, DUMMY_SP),
|
||||
res: LifetimeName::Static,
|
||||
kind: LifetimeKind::Static,
|
||||
is_anon_in_path: IsAnonInPath::No,
|
||||
}
|
||||
},
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ use rustc_errors::ErrorGuaranteed;
|
|||
use rustc_hir::def::{DefKind, Res};
|
||||
use rustc_hir::intravisit::{self, InferKind, Visitor, VisitorExt};
|
||||
use rustc_hir::{
|
||||
self as hir, AmbigArg, GenericArg, GenericParam, GenericParamKind, HirId, LifetimeName, Node,
|
||||
self as hir, AmbigArg, GenericArg, GenericParam, GenericParamKind, HirId, LifetimeKind, Node,
|
||||
};
|
||||
use rustc_macros::extension;
|
||||
use rustc_middle::hir::nested_filter;
|
||||
|
|
@ -646,14 +646,14 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
|
|||
arg: &'tcx hir::PreciseCapturingArg<'tcx>,
|
||||
) -> Self::Result {
|
||||
match *arg {
|
||||
hir::PreciseCapturingArg::Lifetime(lt) => match lt.res {
|
||||
LifetimeName::Param(def_id) => {
|
||||
hir::PreciseCapturingArg::Lifetime(lt) => match lt.kind {
|
||||
LifetimeKind::Param(def_id) => {
|
||||
self.resolve_lifetime_ref(def_id, lt);
|
||||
}
|
||||
LifetimeName::Error => {}
|
||||
LifetimeName::ImplicitObjectLifetimeDefault
|
||||
| LifetimeName::Infer
|
||||
| LifetimeName::Static => {
|
||||
LifetimeKind::Error => {}
|
||||
LifetimeKind::ImplicitObjectLifetimeDefault
|
||||
| LifetimeKind::Infer
|
||||
| LifetimeKind::Static => {
|
||||
self.tcx.dcx().emit_err(errors::BadPreciseCapture {
|
||||
span: lt.ident.span,
|
||||
kind: "lifetime",
|
||||
|
|
@ -774,26 +774,26 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
|
|||
);
|
||||
}
|
||||
});
|
||||
match lifetime.res {
|
||||
LifetimeName::ImplicitObjectLifetimeDefault => {
|
||||
match lifetime.kind {
|
||||
LifetimeKind::ImplicitObjectLifetimeDefault => {
|
||||
// If the user does not write *anything*, we
|
||||
// use the object lifetime defaulting
|
||||
// rules. So e.g., `Box<dyn Debug>` becomes
|
||||
// `Box<dyn Debug + 'static>`.
|
||||
self.resolve_object_lifetime_default(&*lifetime)
|
||||
}
|
||||
LifetimeName::Infer => {
|
||||
LifetimeKind::Infer => {
|
||||
// If the user writes `'_`, we use the *ordinary* elision
|
||||
// rules. So the `'_` in e.g., `Box<dyn Debug + '_>` will be
|
||||
// resolved the same as the `'_` in `&'_ Foo`.
|
||||
//
|
||||
// cc #48468
|
||||
}
|
||||
LifetimeName::Param(..) | LifetimeName::Static => {
|
||||
LifetimeKind::Param(..) | LifetimeKind::Static => {
|
||||
// If the user wrote an explicit name, use that.
|
||||
self.visit_lifetime(&*lifetime);
|
||||
}
|
||||
LifetimeName::Error => {}
|
||||
LifetimeKind::Error => {}
|
||||
}
|
||||
}
|
||||
hir::TyKind::Ref(lifetime_ref, ref mt) => {
|
||||
|
|
@ -873,17 +873,17 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
|
|||
|
||||
#[instrument(level = "debug", skip(self))]
|
||||
fn visit_lifetime(&mut self, lifetime_ref: &'tcx hir::Lifetime) {
|
||||
match lifetime_ref.res {
|
||||
hir::LifetimeName::Static => {
|
||||
match lifetime_ref.kind {
|
||||
hir::LifetimeKind::Static => {
|
||||
self.insert_lifetime(lifetime_ref, ResolvedArg::StaticLifetime)
|
||||
}
|
||||
hir::LifetimeName::Param(param_def_id) => {
|
||||
hir::LifetimeKind::Param(param_def_id) => {
|
||||
self.resolve_lifetime_ref(param_def_id, lifetime_ref)
|
||||
}
|
||||
// If we've already reported an error, just ignore `lifetime_ref`.
|
||||
hir::LifetimeName::Error => {}
|
||||
hir::LifetimeKind::Error => {}
|
||||
// Those will be resolved by typechecking.
|
||||
hir::LifetimeName::ImplicitObjectLifetimeDefault | hir::LifetimeName::Infer => {}
|
||||
hir::LifetimeKind::ImplicitObjectLifetimeDefault | hir::LifetimeKind::Infer => {}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1063,15 +1063,15 @@ fn object_lifetime_default(tcx: TyCtxt<'_>, param_def_id: LocalDefId) -> ObjectL
|
|||
|
||||
for bound in bound.bounds {
|
||||
if let hir::GenericBound::Outlives(lifetime) = bound {
|
||||
set.insert(lifetime.res);
|
||||
set.insert(lifetime.kind);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
match set {
|
||||
Set1::Empty => ObjectLifetimeDefault::Empty,
|
||||
Set1::One(hir::LifetimeName::Static) => ObjectLifetimeDefault::Static,
|
||||
Set1::One(hir::LifetimeName::Param(param_def_id)) => {
|
||||
Set1::One(hir::LifetimeKind::Static) => ObjectLifetimeDefault::Static,
|
||||
Set1::One(hir::LifetimeKind::Param(param_def_id)) => {
|
||||
ObjectLifetimeDefault::Param(param_def_id.to_def_id())
|
||||
}
|
||||
_ => ObjectLifetimeDefault::Ambiguous,
|
||||
|
|
@ -1241,7 +1241,7 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
|
|||
// Fresh lifetimes in APIT used to be allowed in async fns and forbidden in
|
||||
// regular fns.
|
||||
if let Some(hir::PredicateOrigin::ImplTrait) = where_bound_origin
|
||||
&& let hir::LifetimeName::Param(param_id) = lifetime_ref.res
|
||||
&& let hir::LifetimeKind::Param(param_id) = lifetime_ref.kind
|
||||
&& let Some(generics) =
|
||||
self.tcx.hir_get_generics(self.tcx.local_parent(param_id))
|
||||
&& let Some(param) = generics.params.iter().find(|p| p.def_id == param_id)
|
||||
|
|
@ -2440,7 +2440,7 @@ fn is_late_bound_map(
|
|||
}
|
||||
|
||||
fn visit_lifetime(&mut self, lifetime_ref: &'v hir::Lifetime) {
|
||||
if let hir::LifetimeName::Param(def_id) = lifetime_ref.res {
|
||||
if let hir::LifetimeKind::Param(def_id) = lifetime_ref.kind {
|
||||
self.regions.insert(def_id);
|
||||
}
|
||||
}
|
||||
|
|
@ -2453,7 +2453,7 @@ fn is_late_bound_map(
|
|||
|
||||
impl<'tcx> Visitor<'tcx> for AllCollector {
|
||||
fn visit_lifetime(&mut self, lifetime_ref: &'tcx hir::Lifetime) {
|
||||
if let hir::LifetimeName::Param(def_id) = lifetime_ref.res {
|
||||
if let hir::LifetimeKind::Param(def_id) = lifetime_ref.kind {
|
||||
self.regions.insert(def_id);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -415,7 +415,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
|
|||
self.lower_lifetime(lifetime, RegionInferReason::ExplicitObjectLifetime)
|
||||
} else {
|
||||
let reason =
|
||||
if let hir::LifetimeName::ImplicitObjectLifetimeDefault = lifetime.res {
|
||||
if let hir::LifetimeKind::ImplicitObjectLifetimeDefault = lifetime.kind {
|
||||
if let hir::Node::Ty(hir::Ty {
|
||||
kind: hir::TyKind::Ref(parent_lifetime, _),
|
||||
..
|
||||
|
|
|
|||
|
|
@ -83,11 +83,6 @@ enum TargetLint {
|
|||
Ignored,
|
||||
}
|
||||
|
||||
pub enum FindLintError {
|
||||
NotFound,
|
||||
Removed,
|
||||
}
|
||||
|
||||
struct LintAlias {
|
||||
name: &'static str,
|
||||
/// Whether deprecation warnings should be suppressed for this alias.
|
||||
|
|
@ -231,13 +226,24 @@ impl LintStore {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn register_group_alias(&mut self, lint_name: &'static str, alias: &'static str) {
|
||||
self.lint_groups.insert(
|
||||
fn insert_group(&mut self, name: &'static str, group: LintGroup) {
|
||||
let previous = self.lint_groups.insert(name, group);
|
||||
if previous.is_some() {
|
||||
bug!("group {name:?} already exists");
|
||||
}
|
||||
}
|
||||
|
||||
pub fn register_group_alias(&mut self, group_name: &'static str, alias: &'static str) {
|
||||
let Some(LintGroup { lint_ids, .. }) = self.lint_groups.get(group_name) else {
|
||||
bug!("group alias {alias:?} points to unregistered group {group_name:?}")
|
||||
};
|
||||
|
||||
self.insert_group(
|
||||
alias,
|
||||
LintGroup {
|
||||
lint_ids: vec![],
|
||||
lint_ids: lint_ids.clone(),
|
||||
is_externally_loaded: false,
|
||||
depr: Some(LintAlias { name: lint_name, silent: true }),
|
||||
depr: Some(LintAlias { name: group_name, silent: true }),
|
||||
},
|
||||
);
|
||||
}
|
||||
|
|
@ -249,24 +255,17 @@ impl LintStore {
|
|||
deprecated_name: Option<&'static str>,
|
||||
to: Vec<LintId>,
|
||||
) {
|
||||
let new = self
|
||||
.lint_groups
|
||||
.insert(name, LintGroup { lint_ids: to, is_externally_loaded, depr: None })
|
||||
.is_none();
|
||||
if let Some(deprecated) = deprecated_name {
|
||||
self.lint_groups.insert(
|
||||
self.insert_group(
|
||||
deprecated,
|
||||
LintGroup {
|
||||
lint_ids: vec![],
|
||||
lint_ids: to.clone(),
|
||||
is_externally_loaded,
|
||||
depr: Some(LintAlias { name, silent: false }),
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
if !new {
|
||||
bug!("duplicate specification of lint group {}", name);
|
||||
}
|
||||
self.insert_group(name, LintGroup { lint_ids: to, is_externally_loaded, depr: None });
|
||||
}
|
||||
|
||||
/// This lint should give no warning and have no effect.
|
||||
|
|
@ -292,23 +291,15 @@ impl LintStore {
|
|||
self.by_name.insert(name.into(), Removed(reason.into()));
|
||||
}
|
||||
|
||||
pub fn find_lints(&self, mut lint_name: &str) -> Result<Vec<LintId>, FindLintError> {
|
||||
pub fn find_lints(&self, lint_name: &str) -> Option<&[LintId]> {
|
||||
match self.by_name.get(lint_name) {
|
||||
Some(&Id(lint_id)) => Ok(vec![lint_id]),
|
||||
Some(&Renamed(_, lint_id)) => Ok(vec![lint_id]),
|
||||
Some(&Removed(_)) => Err(FindLintError::Removed),
|
||||
Some(&Ignored) => Ok(vec![]),
|
||||
None => loop {
|
||||
return match self.lint_groups.get(lint_name) {
|
||||
Some(LintGroup { lint_ids, depr, .. }) => {
|
||||
if let Some(LintAlias { name, .. }) = depr {
|
||||
lint_name = name;
|
||||
continue;
|
||||
}
|
||||
Ok(lint_ids.clone())
|
||||
}
|
||||
None => Err(FindLintError::Removed),
|
||||
};
|
||||
Some(Id(lint_id)) => Some(slice::from_ref(lint_id)),
|
||||
Some(Renamed(_, lint_id)) => Some(slice::from_ref(lint_id)),
|
||||
Some(Removed(_)) => None,
|
||||
Some(Ignored) => Some(&[]),
|
||||
None => match self.lint_groups.get(lint_name) {
|
||||
Some(LintGroup { lint_ids, .. }) => Some(lint_ids),
|
||||
None => None,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
|
@ -374,8 +365,12 @@ impl LintStore {
|
|||
CheckLintNameResult::MissingTool
|
||||
};
|
||||
}
|
||||
Some(LintGroup { lint_ids, .. }) => {
|
||||
return CheckLintNameResult::Tool(lint_ids, None);
|
||||
Some(LintGroup { lint_ids, depr, .. }) => {
|
||||
return if let &Some(LintAlias { name, silent: false }) = depr {
|
||||
CheckLintNameResult::Tool(lint_ids, Some(name.to_string()))
|
||||
} else {
|
||||
CheckLintNameResult::Tool(lint_ids, None)
|
||||
};
|
||||
}
|
||||
},
|
||||
Some(Id(id)) => return CheckLintNameResult::Tool(slice::from_ref(id), None),
|
||||
|
|
@ -393,16 +388,12 @@ impl LintStore {
|
|||
None => self.check_tool_name_for_backwards_compat(&complete_name, "clippy"),
|
||||
Some(LintGroup { lint_ids, depr, .. }) => {
|
||||
// Check if the lint group name is deprecated
|
||||
if let Some(LintAlias { name, silent }) = depr {
|
||||
let LintGroup { lint_ids, .. } = self.lint_groups.get(name).unwrap();
|
||||
return if *silent {
|
||||
CheckLintNameResult::Ok(lint_ids)
|
||||
if let &Some(LintAlias { name, silent: false }) = depr {
|
||||
CheckLintNameResult::Tool(lint_ids, Some(name.to_string()))
|
||||
} else {
|
||||
CheckLintNameResult::Tool(lint_ids, Some((*name).to_string()))
|
||||
};
|
||||
}
|
||||
CheckLintNameResult::Ok(lint_ids)
|
||||
}
|
||||
}
|
||||
},
|
||||
Some(Id(id)) => CheckLintNameResult::Ok(slice::from_ref(id)),
|
||||
Some(&Ignored) => CheckLintNameResult::Ok(&[]),
|
||||
|
|
@ -412,7 +403,7 @@ impl LintStore {
|
|||
fn no_lint_suggestion(&self, lint_name: &str, tool_name: &str) -> CheckLintNameResult<'_> {
|
||||
let name_lower = lint_name.to_lowercase();
|
||||
|
||||
if lint_name.chars().any(char::is_uppercase) && self.find_lints(&name_lower).is_ok() {
|
||||
if lint_name.chars().any(char::is_uppercase) && self.find_lints(&name_lower).is_some() {
|
||||
// First check if the lint name is (partly) in upper case instead of lower case...
|
||||
return CheckLintNameResult::NoLint(Some((Symbol::intern(&name_lower), false)));
|
||||
}
|
||||
|
|
@ -455,18 +446,8 @@ impl LintStore {
|
|||
None => match self.lint_groups.get(&*complete_name) {
|
||||
// Now we are sure, that this lint exists nowhere
|
||||
None => self.no_lint_suggestion(lint_name, tool_name),
|
||||
Some(LintGroup { lint_ids, depr, .. }) => {
|
||||
// Reaching this would be weird, but let's cover this case anyway
|
||||
if let Some(LintAlias { name, silent }) = depr {
|
||||
let LintGroup { lint_ids, .. } = self.lint_groups.get(name).unwrap();
|
||||
if *silent {
|
||||
Some(LintGroup { lint_ids, .. }) => {
|
||||
CheckLintNameResult::Tool(lint_ids, Some(complete_name))
|
||||
} else {
|
||||
CheckLintNameResult::Tool(lint_ids, Some((*name).to_string()))
|
||||
}
|
||||
} else {
|
||||
CheckLintNameResult::Tool(lint_ids, Some(complete_name))
|
||||
}
|
||||
}
|
||||
},
|
||||
Some(Id(id)) => CheckLintNameResult::Tool(slice::from_ref(id), Some(complete_name)),
|
||||
|
|
|
|||
|
|
@ -517,11 +517,11 @@ impl<'s, P: LintLevelsProvider> LintLevelsBuilder<'s, P> {
|
|||
|
||||
let lint_flag_val = Symbol::intern(lint_name);
|
||||
|
||||
let Ok(ids) = self.store.find_lints(lint_name) else {
|
||||
let Some(ids) = self.store.find_lints(lint_name) else {
|
||||
// errors already handled above
|
||||
continue;
|
||||
};
|
||||
for id in ids {
|
||||
for &id in ids {
|
||||
// ForceWarn and Forbid cannot be overridden
|
||||
if let Some(LevelAndSource { level: Level::ForceWarn | Level::Forbid, .. }) =
|
||||
self.current_specs().get(&id)
|
||||
|
|
|
|||
|
|
@ -124,9 +124,7 @@ use unused::*;
|
|||
|
||||
#[rustfmt::skip]
|
||||
pub use builtin::{MissingDoc, SoftLints};
|
||||
pub use context::{
|
||||
CheckLintNameResult, EarlyContext, FindLintError, LateContext, LintContext, LintStore,
|
||||
};
|
||||
pub use context::{CheckLintNameResult, EarlyContext, LateContext, LintContext, LintStore};
|
||||
pub use early::{EarlyCheckNode, check_ast_node};
|
||||
pub use late::{check_crate, late_lint_mod, unerased_lint_store};
|
||||
pub use levels::LintLevelsBuilder;
|
||||
|
|
|
|||
|
|
@ -578,8 +578,8 @@ impl<'v> hir::intravisit::Visitor<'v> for TraitObjectVisitor<'v> {
|
|||
match ty.kind {
|
||||
hir::TyKind::TraitObject(_, tagged_ptr)
|
||||
if let hir::Lifetime {
|
||||
res:
|
||||
hir::LifetimeName::ImplicitObjectLifetimeDefault | hir::LifetimeName::Static,
|
||||
kind:
|
||||
hir::LifetimeKind::ImplicitObjectLifetimeDefault | hir::LifetimeKind::Static,
|
||||
..
|
||||
} = tagged_ptr.pointer() =>
|
||||
{
|
||||
|
|
|
|||
|
|
@ -806,9 +806,6 @@ parse_trait_alias_cannot_be_unsafe = trait aliases cannot be `unsafe`
|
|||
parse_transpose_dyn_or_impl = `for<...>` expected after `{$kw}`, not before
|
||||
.suggestion = move `{$kw}` before the `for<...>`
|
||||
|
||||
parse_type_ascription_removed =
|
||||
if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
|
||||
|
||||
parse_unclosed_unicode_escape = unterminated unicode escape
|
||||
.label = missing a closing `{"}"}`
|
||||
.terminate = terminate the unicode escape
|
||||
|
|
|
|||
|
|
@ -1598,9 +1598,6 @@ pub(crate) struct PathSingleColon {
|
|||
|
||||
#[suggestion(applicability = "machine-applicable", code = ":", style = "verbose")]
|
||||
pub suggestion: Span,
|
||||
|
||||
#[note(parse_type_ascription_removed)]
|
||||
pub type_ascription: bool,
|
||||
}
|
||||
|
||||
#[derive(Diagnostic)]
|
||||
|
|
@ -1617,9 +1614,6 @@ pub(crate) struct ColonAsSemi {
|
|||
#[primary_span]
|
||||
#[suggestion(applicability = "machine-applicable", code = ";", style = "verbose")]
|
||||
pub span: Span,
|
||||
|
||||
#[note(parse_type_ascription_removed)]
|
||||
pub type_ascription: bool,
|
||||
}
|
||||
|
||||
#[derive(Diagnostic)]
|
||||
|
|
|
|||
|
|
@ -1943,10 +1943,7 @@ impl<'a> Parser<'a> {
|
|||
&& self.token == token::Colon
|
||||
&& self.look_ahead(1, |next| line_idx(self.token.span) < line_idx(next.span))
|
||||
{
|
||||
self.dcx().emit_err(ColonAsSemi {
|
||||
span: self.token.span,
|
||||
type_ascription: self.psess.unstable_features.is_nightly_build(),
|
||||
});
|
||||
self.dcx().emit_err(ColonAsSemi { span: self.token.span });
|
||||
self.bump();
|
||||
return true;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -273,7 +273,6 @@ impl<'a> Parser<'a> {
|
|||
self.dcx().emit_err(PathSingleColon {
|
||||
span: self.prev_token.span,
|
||||
suggestion: self.prev_token.span.shrink_to_hi(),
|
||||
type_ascription: self.psess.unstable_features.is_nightly_build(),
|
||||
});
|
||||
}
|
||||
continue;
|
||||
|
|
@ -348,7 +347,6 @@ impl<'a> Parser<'a> {
|
|||
err = self.dcx().create_err(PathSingleColon {
|
||||
span: self.token.span,
|
||||
suggestion: self.prev_token.span.shrink_to_hi(),
|
||||
type_ascription: self.psess.unstable_features.is_nightly_build(),
|
||||
});
|
||||
}
|
||||
// Attempt to find places where a missing `>` might belong.
|
||||
|
|
|
|||
|
|
@ -771,10 +771,6 @@ impl<'a> Parser<'a> {
|
|||
Applicability::MaybeIncorrect,
|
||||
);
|
||||
}
|
||||
if self.psess.unstable_features.is_nightly_build() {
|
||||
// FIXME(Nilstrieb): Remove this again after a few months.
|
||||
err.note("type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1174,8 +1174,7 @@ pub(super) struct CurrentDepGraph<D: Deps> {
|
|||
/// ID from the previous session. In order to side-step this problem, we make
|
||||
/// sure that anonymous `NodeId`s allocated in different sessions don't overlap.
|
||||
/// This is implemented by mixing a session-key into the ID fingerprint of
|
||||
/// each anon node. The session-key is just a random number generated when
|
||||
/// the `DepGraph` is created.
|
||||
/// each anon node. The session-key is a hash of the number of previous sessions.
|
||||
anon_id_seed: Fingerprint,
|
||||
|
||||
/// These are simple counters that are for profiling and
|
||||
|
|
@ -1193,12 +1192,8 @@ impl<D: Deps> CurrentDepGraph<D> {
|
|||
record_stats: bool,
|
||||
previous: Arc<SerializedDepGraph>,
|
||||
) -> Self {
|
||||
use std::time::{SystemTime, UNIX_EPOCH};
|
||||
|
||||
let duration = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
|
||||
let nanos = duration.as_nanos();
|
||||
let mut stable_hasher = StableHasher::new();
|
||||
nanos.hash(&mut stable_hasher);
|
||||
previous.session_count().hash(&mut stable_hasher);
|
||||
let anon_id_seed = stable_hasher.finish();
|
||||
|
||||
#[cfg(debug_assertions)]
|
||||
|
|
|
|||
|
|
@ -92,6 +92,9 @@ pub struct SerializedDepGraph {
|
|||
/// Stores a map from fingerprints to nodes per dep node kind.
|
||||
/// This is the reciprocal of `nodes`.
|
||||
index: Vec<UnhashMap<PackedFingerprint, SerializedDepNodeIndex>>,
|
||||
/// The number of previous compilation sessions. This is used to generate
|
||||
/// unique anon dep nodes per session.
|
||||
session_count: u64,
|
||||
}
|
||||
|
||||
impl SerializedDepGraph {
|
||||
|
|
@ -146,6 +149,11 @@ impl SerializedDepGraph {
|
|||
pub fn node_count(&self) -> usize {
|
||||
self.nodes.len()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn session_count(&self) -> u64 {
|
||||
self.session_count
|
||||
}
|
||||
}
|
||||
|
||||
/// A packed representation of an edge's start index and byte width.
|
||||
|
|
@ -252,6 +260,8 @@ impl SerializedDepGraph {
|
|||
.map(|_| UnhashMap::with_capacity_and_hasher(d.read_u32() as usize, Default::default()))
|
||||
.collect();
|
||||
|
||||
let session_count = d.read_u64();
|
||||
|
||||
for (idx, node) in nodes.iter_enumerated() {
|
||||
if index[node.kind.as_usize()].insert(node.hash, idx).is_some() {
|
||||
// Side effect nodes can have duplicates
|
||||
|
|
@ -273,6 +283,7 @@ impl SerializedDepGraph {
|
|||
edge_list_indices,
|
||||
edge_list_data,
|
||||
index,
|
||||
session_count,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
|
@ -603,7 +614,7 @@ impl<D: Deps> EncoderState<D> {
|
|||
stats: _,
|
||||
kind_stats,
|
||||
marker: _,
|
||||
previous: _,
|
||||
previous,
|
||||
} = self;
|
||||
|
||||
let node_count = total_node_count.try_into().unwrap();
|
||||
|
|
@ -614,6 +625,8 @@ impl<D: Deps> EncoderState<D> {
|
|||
count.encode(&mut encoder);
|
||||
}
|
||||
|
||||
previous.session_count.checked_add(1).unwrap().encode(&mut encoder);
|
||||
|
||||
debug!(?node_count, ?edge_count);
|
||||
debug!("position: {:?}", encoder.position());
|
||||
IntEncodedWithFixedSize(node_count).encode(&mut encoder);
|
||||
|
|
|
|||
|
|
@ -2007,16 +2007,16 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
|
|||
result,
|
||||
result.map(|r| r.expn_data())
|
||||
);
|
||||
// Then find the last semi-transparent mark from the end if it exists.
|
||||
// Then find the last semi-opaque mark from the end if it exists.
|
||||
for (mark, transparency) in iter {
|
||||
if transparency == Transparency::SemiTransparent {
|
||||
if transparency == Transparency::SemiOpaque {
|
||||
result = Some(mark);
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
debug!(
|
||||
"resolve_crate_root: found semi-transparent mark {:?} {:?}",
|
||||
"resolve_crate_root: found semi-opaque mark {:?} {:?}",
|
||||
result,
|
||||
result.map(|r| r.expn_data())
|
||||
);
|
||||
|
|
|
|||
|
|
@ -63,10 +63,10 @@ struct SyntaxContextData {
|
|||
outer_expn: ExpnId,
|
||||
outer_transparency: Transparency,
|
||||
parent: SyntaxContext,
|
||||
/// This context, but with all transparent and semi-transparent expansions filtered away.
|
||||
/// This context, but with all transparent and semi-opaque expansions filtered away.
|
||||
opaque: SyntaxContext,
|
||||
/// This context, but with all transparent expansions filtered away.
|
||||
opaque_and_semitransparent: SyntaxContext,
|
||||
opaque_and_semiopaque: SyntaxContext,
|
||||
/// Name of the crate to which `$crate` with this context would resolve.
|
||||
dollar_crate_name: Symbol,
|
||||
}
|
||||
|
|
@ -75,14 +75,14 @@ impl SyntaxContextData {
|
|||
fn new(
|
||||
(parent, outer_expn, outer_transparency): SyntaxContextKey,
|
||||
opaque: SyntaxContext,
|
||||
opaque_and_semitransparent: SyntaxContext,
|
||||
opaque_and_semiopaque: SyntaxContext,
|
||||
) -> SyntaxContextData {
|
||||
SyntaxContextData {
|
||||
outer_expn,
|
||||
outer_transparency,
|
||||
parent,
|
||||
opaque,
|
||||
opaque_and_semitransparent,
|
||||
opaque_and_semiopaque,
|
||||
dollar_crate_name: kw::DollarCrate,
|
||||
}
|
||||
}
|
||||
|
|
@ -93,7 +93,7 @@ impl SyntaxContextData {
|
|||
outer_transparency: Transparency::Opaque,
|
||||
parent: SyntaxContext::root(),
|
||||
opaque: SyntaxContext::root(),
|
||||
opaque_and_semitransparent: SyntaxContext::root(),
|
||||
opaque_and_semiopaque: SyntaxContext::root(),
|
||||
dollar_crate_name: kw::DollarCrate,
|
||||
}
|
||||
}
|
||||
|
|
@ -204,13 +204,13 @@ pub enum Transparency {
|
|||
/// Identifier produced by a transparent expansion is always resolved at call-site.
|
||||
/// Call-site spans in procedural macros, hygiene opt-out in `macro` should use this.
|
||||
Transparent,
|
||||
/// Identifier produced by a semi-transparent expansion may be resolved
|
||||
/// Identifier produced by a semi-opaque expansion may be resolved
|
||||
/// either at call-site or at definition-site.
|
||||
/// If it's a local variable, label or `$crate` then it's resolved at def-site.
|
||||
/// Otherwise it's resolved at call-site.
|
||||
/// `macro_rules` macros behave like this, built-in macros currently behave like this too,
|
||||
/// but that's an implementation detail.
|
||||
SemiTransparent,
|
||||
SemiOpaque,
|
||||
/// Identifier produced by an opaque expansion is always resolved at definition-site.
|
||||
/// Def-site spans in procedural macros, identifiers from `macro` by default use this.
|
||||
Opaque,
|
||||
|
|
@ -218,7 +218,7 @@ pub enum Transparency {
|
|||
|
||||
impl Transparency {
|
||||
pub fn fallback(macro_rules: bool) -> Self {
|
||||
if macro_rules { Transparency::SemiTransparent } else { Transparency::Opaque }
|
||||
if macro_rules { Transparency::SemiOpaque } else { Transparency::Opaque }
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -466,7 +466,7 @@ impl HygieneData {
|
|||
|
||||
fn normalize_to_macro_rules(&self, ctxt: SyntaxContext) -> SyntaxContext {
|
||||
debug_assert!(!self.syntax_context_data[ctxt.0 as usize].is_decode_placeholder());
|
||||
self.syntax_context_data[ctxt.0 as usize].opaque_and_semitransparent
|
||||
self.syntax_context_data[ctxt.0 as usize].opaque_and_semiopaque
|
||||
}
|
||||
|
||||
fn outer_expn(&self, ctxt: SyntaxContext) -> ExpnId {
|
||||
|
|
@ -559,7 +559,7 @@ impl HygieneData {
|
|||
}
|
||||
|
||||
let call_site_ctxt = self.expn_data(expn_id).call_site.ctxt();
|
||||
let mut call_site_ctxt = if transparency == Transparency::SemiTransparent {
|
||||
let mut call_site_ctxt = if transparency == Transparency::SemiOpaque {
|
||||
self.normalize_to_macros_2_0(call_site_ctxt)
|
||||
} else {
|
||||
self.normalize_to_macro_rules(call_site_ctxt)
|
||||
|
|
@ -605,33 +605,32 @@ impl HygieneData {
|
|||
self.syntax_context_data.push(SyntaxContextData::decode_placeholder());
|
||||
self.syntax_context_map.insert(key, ctxt);
|
||||
|
||||
// Opaque and semi-transparent versions of the parent. Note that they may be equal to the
|
||||
// Opaque and semi-opaque versions of the parent. Note that they may be equal to the
|
||||
// parent itself. E.g. `parent_opaque` == `parent` if the expn chain contains only opaques,
|
||||
// and `parent_opaque_and_semitransparent` == `parent` if the expn contains only opaques
|
||||
// and semi-transparents.
|
||||
// and `parent_opaque_and_semiopaque` == `parent` if the expn contains only (semi-)opaques.
|
||||
let parent_opaque = self.syntax_context_data[parent.0 as usize].opaque;
|
||||
let parent_opaque_and_semitransparent =
|
||||
self.syntax_context_data[parent.0 as usize].opaque_and_semitransparent;
|
||||
let parent_opaque_and_semiopaque =
|
||||
self.syntax_context_data[parent.0 as usize].opaque_and_semiopaque;
|
||||
|
||||
// Evaluate opaque and semi-transparent versions of the new syntax context.
|
||||
let (opaque, opaque_and_semitransparent) = match transparency {
|
||||
Transparency::Transparent => (parent_opaque, parent_opaque_and_semitransparent),
|
||||
Transparency::SemiTransparent => (
|
||||
// Evaluate opaque and semi-opaque versions of the new syntax context.
|
||||
let (opaque, opaque_and_semiopaque) = match transparency {
|
||||
Transparency::Transparent => (parent_opaque, parent_opaque_and_semiopaque),
|
||||
Transparency::SemiOpaque => (
|
||||
parent_opaque,
|
||||
// Will be the same as `ctxt` if the expn chain contains only opaques and semi-transparents.
|
||||
self.alloc_ctxt(parent_opaque_and_semitransparent, expn_id, transparency),
|
||||
// Will be the same as `ctxt` if the expn chain contains only (semi-)opaques.
|
||||
self.alloc_ctxt(parent_opaque_and_semiopaque, expn_id, transparency),
|
||||
),
|
||||
Transparency::Opaque => (
|
||||
// Will be the same as `ctxt` if the expn chain contains only opaques.
|
||||
self.alloc_ctxt(parent_opaque, expn_id, transparency),
|
||||
// Will be the same as `ctxt` if the expn chain contains only opaques and semi-transparents.
|
||||
self.alloc_ctxt(parent_opaque_and_semitransparent, expn_id, transparency),
|
||||
// Will be the same as `ctxt` if the expn chain contains only (semi-)opaques.
|
||||
self.alloc_ctxt(parent_opaque_and_semiopaque, expn_id, transparency),
|
||||
),
|
||||
};
|
||||
|
||||
// Fill the full data, now that we have it.
|
||||
self.syntax_context_data[ctxt.as_u32() as usize] =
|
||||
SyntaxContextData::new(key, opaque, opaque_and_semitransparent);
|
||||
SyntaxContextData::new(key, opaque, opaque_and_semiopaque);
|
||||
ctxt
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1117,7 +1117,7 @@ impl Span {
|
|||
/// Equivalent of `Span::mixed_site` from the proc macro API,
|
||||
/// except that the location is taken from the `self` span.
|
||||
pub fn with_mixed_site_ctxt(self, expn_id: ExpnId) -> Span {
|
||||
self.with_ctxt_from_mark(expn_id, Transparency::SemiTransparent)
|
||||
self.with_ctxt_from_mark(expn_id, Transparency::SemiOpaque)
|
||||
}
|
||||
|
||||
/// Produces a span with the same location as `self` and context produced by a macro with the
|
||||
|
|
|
|||
|
|
@ -1882,6 +1882,7 @@ symbols! {
|
|||
select_unpredictable,
|
||||
self_in_typedefs,
|
||||
self_struct_ctor,
|
||||
semiopaque,
|
||||
semitransparent,
|
||||
sha2,
|
||||
sha3,
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@ use rustc_hir::def_id::DefId;
|
|||
use rustc_hir::intravisit::{Visitor, VisitorExt, walk_ty};
|
||||
use rustc_hir::{
|
||||
self as hir, AmbigArg, GenericBound, GenericParam, GenericParamKind, Item, ItemKind, Lifetime,
|
||||
LifetimeName, LifetimeParamKind, MissingLifetimeKind, Node, TyKind,
|
||||
LifetimeKind, LifetimeParamKind, MissingLifetimeKind, Node, TyKind,
|
||||
};
|
||||
use rustc_middle::ty::{self, Ty, TyCtxt, TypeSuperVisitable, TypeVisitor};
|
||||
use rustc_span::def_id::LocalDefId;
|
||||
|
|
@ -165,7 +165,7 @@ pub fn suggest_new_region_bound(
|
|||
|
||||
if let Some(span) = opaque.bounds.iter().find_map(|arg| match arg {
|
||||
GenericBound::Outlives(Lifetime {
|
||||
res: LifetimeName::Static, ident, ..
|
||||
kind: LifetimeKind::Static, ident, ..
|
||||
}) => Some(ident.span),
|
||||
_ => None,
|
||||
}) {
|
||||
|
|
@ -253,7 +253,7 @@ pub fn suggest_new_region_bound(
|
|||
}
|
||||
}
|
||||
TyKind::TraitObject(_, lt) => {
|
||||
if let LifetimeName::ImplicitObjectLifetimeDefault = lt.res {
|
||||
if let LifetimeKind::ImplicitObjectLifetimeDefault = lt.kind {
|
||||
err.span_suggestion_verbose(
|
||||
fn_return.span.shrink_to_hi(),
|
||||
format!("{declare} the trait object {captures}, {explicit}",),
|
||||
|
|
@ -414,7 +414,7 @@ pub struct HirTraitObjectVisitor<'a>(pub &'a mut Vec<Span>, pub DefId);
|
|||
impl<'a, 'tcx> Visitor<'tcx> for HirTraitObjectVisitor<'a> {
|
||||
fn visit_ty(&mut self, t: &'tcx hir::Ty<'tcx, AmbigArg>) {
|
||||
if let TyKind::TraitObject(poly_trait_refs, lifetime_ptr) = t.kind
|
||||
&& let Lifetime { res: LifetimeName::ImplicitObjectLifetimeDefault, .. } =
|
||||
&& let Lifetime { kind: LifetimeKind::ImplicitObjectLifetimeDefault, .. } =
|
||||
lifetime_ptr.pointer()
|
||||
{
|
||||
for ptr in poly_trait_refs {
|
||||
|
|
|
|||
|
|
@ -850,14 +850,14 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
|
|||
add_lt_suggs: &mut Vec<(Span, String)>,
|
||||
) -> String {
|
||||
struct LifetimeReplaceVisitor<'a> {
|
||||
needle: hir::LifetimeName,
|
||||
needle: hir::LifetimeKind,
|
||||
new_lt: &'a str,
|
||||
add_lt_suggs: &'a mut Vec<(Span, String)>,
|
||||
}
|
||||
|
||||
impl<'hir> hir::intravisit::Visitor<'hir> for LifetimeReplaceVisitor<'_> {
|
||||
fn visit_lifetime(&mut self, lt: &'hir hir::Lifetime) {
|
||||
if lt.res == self.needle {
|
||||
if lt.kind == self.needle {
|
||||
self.add_lt_suggs.push(lt.suggestion(self.new_lt));
|
||||
}
|
||||
}
|
||||
|
|
@ -894,7 +894,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
|
|||
};
|
||||
|
||||
let mut visitor = LifetimeReplaceVisitor {
|
||||
needle: hir::LifetimeName::Param(lifetime_def_id),
|
||||
needle: hir::LifetimeKind::Param(lifetime_def_id),
|
||||
add_lt_suggs,
|
||||
new_lt: &new_lt,
|
||||
};
|
||||
|
|
|
|||
|
|
@ -61,11 +61,11 @@ Here is a summary:
|
|||
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| Describe the *syntax* of a type: what the user wrote (with some desugaring). | Describe the *semantics* of a type: the meaning of what the user wrote. |
|
||||
| Each `rustc_hir::Ty` has its own spans corresponding to the appropriate place in the program. | Doesn’t correspond to a single place in the user’s program. |
|
||||
| `rustc_hir::Ty` has generics and lifetimes; however, some of those lifetimes are special markers like [`LifetimeName::Implicit`][implicit]. | `ty::Ty` has the full type, including generics and lifetimes, even if the user left them out |
|
||||
| `rustc_hir::Ty` has generics and lifetimes; however, some of those lifetimes are special markers like [`LifetimeKind::Implicit`][implicit]. | `ty::Ty` has the full type, including generics and lifetimes, even if the user left them out |
|
||||
| `fn foo(x: u32) → u32 { }` - Two `rustc_hir::Ty` representing each usage of `u32`, each has its own `Span`s, and `rustc_hir::Ty` doesn’t tell us that both are the same type | `fn foo(x: u32) → u32 { }` - One `ty::Ty` for all instances of `u32` throughout the program, and `ty::Ty` tells us that both usages of `u32` mean the same type. |
|
||||
| `fn foo(x: &u32) -> &u32)` - Two `rustc_hir::Ty` again. Lifetimes for the references show up in the `rustc_hir::Ty`s using a special marker, [`LifetimeName::Implicit`][implicit]. | `fn foo(x: &u32) -> &u32)`- A single `ty::Ty`. The `ty::Ty` has the hidden lifetime param. |
|
||||
| `fn foo(x: &u32) -> &u32)` - Two `rustc_hir::Ty` again. Lifetimes for the references show up in the `rustc_hir::Ty`s using a special marker, [`LifetimeKind::Implicit`][implicit]. | `fn foo(x: &u32) -> &u32)`- A single `ty::Ty`. The `ty::Ty` has the hidden lifetime param. |
|
||||
|
||||
[implicit]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/hir/enum.LifetimeName.html#variant.Implicit
|
||||
[implicit]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_hir/hir/enum.LifetimeKind.html#variant.Implicit
|
||||
|
||||
**Order**
|
||||
|
||||
|
|
|
|||
|
|
@ -117,7 +117,14 @@ pub(crate) fn clean_doc_module<'tcx>(doc: &DocModule<'tcx>, cx: &mut DocContext<
|
|||
hir::ItemKind::Use(path, kind) => {
|
||||
let hir::UsePath { segments, span, .. } = *path;
|
||||
let path = hir::Path { segments, res: *res, span };
|
||||
clean_use_statement_inner(import, name, &path, kind, cx, &mut Default::default())
|
||||
clean_use_statement_inner(
|
||||
import,
|
||||
Some(name),
|
||||
&path,
|
||||
kind,
|
||||
cx,
|
||||
&mut Default::default(),
|
||||
)
|
||||
}
|
||||
_ => unreachable!(),
|
||||
}
|
||||
|
|
@ -125,8 +132,7 @@ pub(crate) fn clean_doc_module<'tcx>(doc: &DocModule<'tcx>, cx: &mut DocContext<
|
|||
items.extend(doc.items.values().flat_map(|(item, renamed, _)| {
|
||||
// Now we actually lower the imports, skipping everything else.
|
||||
if let hir::ItemKind::Use(path, hir::UseKind::Glob) = item.kind {
|
||||
let name = renamed.unwrap_or(kw::Empty); // using kw::Empty is a bit of a hack
|
||||
clean_use_statement(item, name, path, hir::UseKind::Glob, cx, &mut inserted)
|
||||
clean_use_statement(item, *renamed, path, hir::UseKind::Glob, cx, &mut inserted)
|
||||
} else {
|
||||
// skip everything else
|
||||
Vec::new()
|
||||
|
|
@ -1072,10 +1078,10 @@ fn clean_fn_decl_legacy_const_generics(func: &mut Function, attrs: &[hir::Attrib
|
|||
..
|
||||
} = param
|
||||
{
|
||||
func.decl
|
||||
.inputs
|
||||
.values
|
||||
.insert(a.get() as _, Argument { name, type_: *ty, is_const: true });
|
||||
func.decl.inputs.values.insert(
|
||||
a.get() as _,
|
||||
Argument { name: Some(name), type_: *ty, is_const: true },
|
||||
);
|
||||
} else {
|
||||
panic!("unexpected non const in position {pos}");
|
||||
}
|
||||
|
|
@ -1132,9 +1138,9 @@ fn clean_args_from_types_and_names<'tcx>(
|
|||
// If at least one argument has a name, use `_` as the name of unnamed
|
||||
// arguments. Otherwise omit argument names.
|
||||
let default_name = if idents.iter().any(|ident| nonempty_name(ident).is_some()) {
|
||||
kw::Underscore
|
||||
Some(kw::Underscore)
|
||||
} else {
|
||||
kw::Empty
|
||||
None
|
||||
};
|
||||
|
||||
Arguments {
|
||||
|
|
@ -1143,7 +1149,7 @@ fn clean_args_from_types_and_names<'tcx>(
|
|||
.enumerate()
|
||||
.map(|(i, ty)| Argument {
|
||||
type_: clean_ty(ty, cx),
|
||||
name: idents.get(i).and_then(nonempty_name).unwrap_or(default_name),
|
||||
name: idents.get(i).and_then(nonempty_name).or(default_name),
|
||||
is_const: false,
|
||||
})
|
||||
.collect(),
|
||||
|
|
@ -1162,7 +1168,7 @@ fn clean_args_from_types_and_body_id<'tcx>(
|
|||
.iter()
|
||||
.zip(body.params)
|
||||
.map(|(ty, param)| Argument {
|
||||
name: name_from_pat(param.pat),
|
||||
name: Some(name_from_pat(param.pat)),
|
||||
type_: clean_ty(ty, cx),
|
||||
is_const: false,
|
||||
})
|
||||
|
|
@ -1218,11 +1224,11 @@ fn clean_poly_fn_sig<'tcx>(
|
|||
.iter()
|
||||
.map(|t| Argument {
|
||||
type_: clean_middle_ty(t.map_bound(|t| *t), cx, None, None),
|
||||
name: if let Some(Some(ident)) = names.next() {
|
||||
name: Some(if let Some(Some(ident)) = names.next() {
|
||||
ident.name
|
||||
} else {
|
||||
kw::Underscore
|
||||
},
|
||||
}),
|
||||
is_const: false,
|
||||
})
|
||||
.collect(),
|
||||
|
|
@ -2792,10 +2798,7 @@ fn clean_maybe_renamed_item<'tcx>(
|
|||
use hir::ItemKind;
|
||||
|
||||
let def_id = item.owner_id.to_def_id();
|
||||
let mut name = renamed.unwrap_or_else(|| {
|
||||
// FIXME: using kw::Empty is a bit of a hack
|
||||
cx.tcx.hir_opt_name(item.hir_id()).unwrap_or(kw::Empty)
|
||||
});
|
||||
let mut name = if renamed.is_some() { renamed } else { cx.tcx.hir_opt_name(item.hir_id()) };
|
||||
|
||||
cx.with_param_env(def_id, |cx| {
|
||||
let kind = match item.kind {
|
||||
|
|
@ -2836,7 +2839,7 @@ fn clean_maybe_renamed_item<'tcx>(
|
|||
item_type: Some(type_),
|
||||
})),
|
||||
item.owner_id.def_id.to_def_id(),
|
||||
name,
|
||||
name.unwrap(),
|
||||
import_id,
|
||||
renamed,
|
||||
));
|
||||
|
|
@ -2861,13 +2864,15 @@ fn clean_maybe_renamed_item<'tcx>(
|
|||
}),
|
||||
ItemKind::Impl(impl_) => return clean_impl(impl_, item.owner_id.def_id, cx),
|
||||
ItemKind::Macro(_, macro_def, MacroKind::Bang) => MacroItem(Macro {
|
||||
source: display_macro_source(cx, name, macro_def),
|
||||
source: display_macro_source(cx, name.unwrap(), macro_def),
|
||||
macro_rules: macro_def.macro_rules,
|
||||
}),
|
||||
ItemKind::Macro(_, _, macro_kind) => clean_proc_macro(item, &mut name, macro_kind, cx),
|
||||
ItemKind::Macro(_, _, macro_kind) => {
|
||||
clean_proc_macro(item, name.as_mut().unwrap(), macro_kind, cx)
|
||||
}
|
||||
// proc macros can have a name set by attributes
|
||||
ItemKind::Fn { ref sig, generics, body: body_id, .. } => {
|
||||
clean_fn_or_proc_macro(item, sig, generics, body_id, &mut name, cx)
|
||||
clean_fn_or_proc_macro(item, sig, generics, body_id, name.as_mut().unwrap(), cx)
|
||||
}
|
||||
ItemKind::Trait(_, _, _, generics, bounds, item_ids) => {
|
||||
let items = item_ids
|
||||
|
|
@ -2883,7 +2888,7 @@ fn clean_maybe_renamed_item<'tcx>(
|
|||
}))
|
||||
}
|
||||
ItemKind::ExternCrate(orig_name, _) => {
|
||||
return clean_extern_crate(item, name, orig_name, cx);
|
||||
return clean_extern_crate(item, name.unwrap(), orig_name, cx);
|
||||
}
|
||||
ItemKind::Use(path, kind) => {
|
||||
return clean_use_statement(item, name, path, kind, cx, &mut FxHashSet::default());
|
||||
|
|
@ -2895,7 +2900,7 @@ fn clean_maybe_renamed_item<'tcx>(
|
|||
cx,
|
||||
kind,
|
||||
item.owner_id.def_id.to_def_id(),
|
||||
name,
|
||||
name.unwrap(),
|
||||
import_id,
|
||||
renamed,
|
||||
)]
|
||||
|
|
@ -3006,7 +3011,7 @@ fn clean_extern_crate<'tcx>(
|
|||
|
||||
fn clean_use_statement<'tcx>(
|
||||
import: &hir::Item<'tcx>,
|
||||
name: Symbol,
|
||||
name: Option<Symbol>,
|
||||
path: &hir::UsePath<'tcx>,
|
||||
kind: hir::UseKind,
|
||||
cx: &mut DocContext<'tcx>,
|
||||
|
|
@ -3023,7 +3028,7 @@ fn clean_use_statement<'tcx>(
|
|||
|
||||
fn clean_use_statement_inner<'tcx>(
|
||||
import: &hir::Item<'tcx>,
|
||||
name: Symbol,
|
||||
name: Option<Symbol>,
|
||||
path: &hir::Path<'tcx>,
|
||||
kind: hir::UseKind,
|
||||
cx: &mut DocContext<'tcx>,
|
||||
|
|
@ -3042,7 +3047,7 @@ fn clean_use_statement_inner<'tcx>(
|
|||
let visibility = cx.tcx.visibility(import.owner_id);
|
||||
let attrs = cx.tcx.hir_attrs(import.hir_id());
|
||||
let inline_attr = hir_attr_lists(attrs, sym::doc).get_word_attr(sym::inline);
|
||||
let pub_underscore = visibility.is_public() && name == kw::Underscore;
|
||||
let pub_underscore = visibility.is_public() && name == Some(kw::Underscore);
|
||||
let current_mod = cx.tcx.parent_module_from_def_id(import.owner_id.def_id);
|
||||
let import_def_id = import.owner_id.def_id;
|
||||
|
||||
|
|
@ -3108,6 +3113,7 @@ fn clean_use_statement_inner<'tcx>(
|
|||
}
|
||||
Import::new_glob(resolve_use_source(cx, path), true)
|
||||
} else {
|
||||
let name = name.unwrap();
|
||||
if inline_attr.is_none()
|
||||
&& let Res::Def(DefKind::Mod, did) = path.res
|
||||
&& !did.is_local()
|
||||
|
|
|
|||
|
|
@ -1426,7 +1426,7 @@ pub(crate) struct Arguments {
|
|||
#[derive(Clone, PartialEq, Eq, Debug, Hash)]
|
||||
pub(crate) struct Argument {
|
||||
pub(crate) type_: Type,
|
||||
pub(crate) name: Symbol,
|
||||
pub(crate) name: Option<Symbol>,
|
||||
/// This field is used to represent "const" arguments from the `rustc_legacy_const_generics`
|
||||
/// feature. More information in <https://github.com/rust-lang/rust/issues/83167>.
|
||||
pub(crate) is_const: bool,
|
||||
|
|
@ -1434,7 +1434,7 @@ pub(crate) struct Argument {
|
|||
|
||||
impl Argument {
|
||||
pub(crate) fn to_receiver(&self) -> Option<&Type> {
|
||||
if self.name == kw::SelfLower { Some(&self.type_) } else { None }
|
||||
if self.name == Some(kw::SelfLower) { Some(&self.type_) } else { None }
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -234,7 +234,7 @@ pub(super) fn clean_middle_path<'tcx>(
|
|||
args: ty::Binder<'tcx, GenericArgsRef<'tcx>>,
|
||||
) -> Path {
|
||||
let def_kind = cx.tcx.def_kind(did);
|
||||
let name = cx.tcx.opt_item_name(did).unwrap_or(kw::Empty);
|
||||
let name = cx.tcx.opt_item_name(did).unwrap_or(sym::dummy);
|
||||
Path {
|
||||
res: Res::Def(def_kind, did),
|
||||
segments: thin_vec![PathSegment {
|
||||
|
|
|
|||
|
|
@ -1241,8 +1241,8 @@ impl clean::Arguments {
|
|||
.iter()
|
||||
.map(|input| {
|
||||
fmt::from_fn(|f| {
|
||||
if !input.name.is_empty() {
|
||||
write!(f, "{}: ", input.name)?;
|
||||
if let Some(name) = input.name {
|
||||
write!(f, "{}: ", name)?;
|
||||
}
|
||||
input.type_.print(cx).fmt(f)
|
||||
})
|
||||
|
|
@ -1364,7 +1364,9 @@ impl clean::FnDecl {
|
|||
if input.is_const {
|
||||
write!(f, "const ")?;
|
||||
}
|
||||
write!(f, "{}: ", input.name)?;
|
||||
if let Some(name) = input.name {
|
||||
write!(f, "{}: ", name)?;
|
||||
}
|
||||
input.type_.print(cx).fmt(f)?;
|
||||
}
|
||||
match (line_wrapping_indent, last_input_index) {
|
||||
|
|
|
|||
|
|
@ -223,7 +223,7 @@ pub(crate) struct IndexItemFunctionType {
|
|||
inputs: Vec<RenderType>,
|
||||
output: Vec<RenderType>,
|
||||
where_clause: Vec<Vec<RenderType>>,
|
||||
param_names: Vec<Symbol>,
|
||||
param_names: Vec<Option<Symbol>>,
|
||||
}
|
||||
|
||||
impl IndexItemFunctionType {
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ use rustc_hir::def_id::DefId;
|
|||
use rustc_index::IndexVec;
|
||||
use rustc_middle::ty::{self, TyCtxt};
|
||||
use rustc_span::hygiene::MacroKind;
|
||||
use rustc_span::symbol::{Symbol, kw, sym};
|
||||
use rustc_span::symbol::{Symbol, sym};
|
||||
use tracing::{debug, info};
|
||||
|
||||
use super::type_layout::document_type_layout;
|
||||
|
|
@ -347,9 +347,12 @@ fn item_module(cx: &Context<'_>, item: &clean::Item, items: &[clean::Item]) -> i
|
|||
// but we actually want stable items to come first
|
||||
return is_stable2.cmp(&is_stable1);
|
||||
}
|
||||
let lhs = i1.name.unwrap_or(kw::Empty);
|
||||
let rhs = i2.name.unwrap_or(kw::Empty);
|
||||
compare_names(lhs.as_str(), rhs.as_str())
|
||||
match (i1.name, i2.name) {
|
||||
(Some(name1), Some(name2)) => compare_names(name1.as_str(), name2.as_str()),
|
||||
(Some(_), None) => Ordering::Greater,
|
||||
(None, Some(_)) => Ordering::Less,
|
||||
(None, None) => Ordering::Equal,
|
||||
}
|
||||
}
|
||||
|
||||
let tcx = cx.tcx();
|
||||
|
|
|
|||
|
|
@ -709,8 +709,11 @@ pub(crate) fn build_index(
|
|||
let mut result = Vec::new();
|
||||
for (index, item) in self.items.iter().enumerate() {
|
||||
if let Some(ty) = &item.search_type
|
||||
&& let my =
|
||||
ty.param_names.iter().map(|sym| sym.as_str()).collect::<Vec<_>>()
|
||||
&& let my = ty
|
||||
.param_names
|
||||
.iter()
|
||||
.filter_map(|sym| sym.map(|sym| sym.to_string()))
|
||||
.collect::<Vec<_>>()
|
||||
&& my != prev
|
||||
{
|
||||
result.push((index, my.join(",")));
|
||||
|
|
@ -1372,7 +1375,7 @@ fn simplify_fn_constraint<'a>(
|
|||
/// Used to allow type-based search on constants and statics.
|
||||
fn make_nullary_fn(
|
||||
clean_type: &clean::Type,
|
||||
) -> (Vec<RenderType>, Vec<RenderType>, Vec<Symbol>, Vec<Vec<RenderType>>) {
|
||||
) -> (Vec<RenderType>, Vec<RenderType>, Vec<Option<Symbol>>, Vec<Vec<RenderType>>) {
|
||||
let mut rgen: FxIndexMap<SimplifiedParam, (isize, Vec<RenderType>)> = Default::default();
|
||||
let output = get_index_type(clean_type, vec![], &mut rgen);
|
||||
(vec![], vec![output], vec![], vec![])
|
||||
|
|
@ -1387,7 +1390,7 @@ fn get_fn_inputs_and_outputs(
|
|||
tcx: TyCtxt<'_>,
|
||||
impl_or_trait_generics: Option<&(clean::Type, clean::Generics)>,
|
||||
cache: &Cache,
|
||||
) -> (Vec<RenderType>, Vec<RenderType>, Vec<Symbol>, Vec<Vec<RenderType>>) {
|
||||
) -> (Vec<RenderType>, Vec<RenderType>, Vec<Option<Symbol>>, Vec<Vec<RenderType>>) {
|
||||
let decl = &func.decl;
|
||||
|
||||
let mut rgen: FxIndexMap<SimplifiedParam, (isize, Vec<RenderType>)> = Default::default();
|
||||
|
|
@ -1441,10 +1444,10 @@ fn get_fn_inputs_and_outputs(
|
|||
simplified_params
|
||||
.iter()
|
||||
.map(|(name, (_idx, _traits))| match name {
|
||||
SimplifiedParam::Symbol(name) => *name,
|
||||
SimplifiedParam::Anonymous(_) => kw::Empty,
|
||||
SimplifiedParam::Symbol(name) => Some(*name),
|
||||
SimplifiedParam::Anonymous(_) => None,
|
||||
SimplifiedParam::AssociatedType(def_id, name) => {
|
||||
Symbol::intern(&format!("{}::{}", tcx.item_name(*def_id), name))
|
||||
Some(Symbol::intern(&format!("{}::{}", tcx.item_name(*def_id), name)))
|
||||
}
|
||||
})
|
||||
.collect(),
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ use rustc_hir::def::CtorKind;
|
|||
use rustc_hir::def_id::DefId;
|
||||
use rustc_metadata::rendered_const;
|
||||
use rustc_middle::{bug, ty};
|
||||
use rustc_span::{Pos, Symbol};
|
||||
use rustc_span::{Pos, Symbol, kw};
|
||||
use rustdoc_json_types::*;
|
||||
|
||||
use crate::clean::{self, ItemId};
|
||||
|
|
@ -611,7 +611,10 @@ impl FromClean<clean::FnDecl> for FunctionSignature {
|
|||
inputs: inputs
|
||||
.values
|
||||
.into_iter()
|
||||
.map(|arg| (arg.name.to_string(), arg.type_.into_json(renderer)))
|
||||
// `_` is the most sensible name for missing param names.
|
||||
.map(|arg| {
|
||||
(arg.name.unwrap_or(kw::Underscore).to_string(), arg.type_.into_json(renderer))
|
||||
})
|
||||
.collect(),
|
||||
output: if output.is_unit() { None } else { Some(output.into_json(renderer)) },
|
||||
is_c_variadic: c_variadic,
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@ use rustc_hir::intravisit::{
|
|||
};
|
||||
use rustc_hir::{
|
||||
AmbigArg, BareFnTy, BodyId, FnDecl, FnSig, GenericArg, GenericArgs, GenericBound, GenericParam, GenericParamKind,
|
||||
Generics, HirId, Impl, ImplItem, ImplItemKind, Item, ItemKind, Lifetime, LifetimeName, LifetimeParamKind, Node,
|
||||
Generics, HirId, Impl, ImplItem, ImplItemKind, Item, ItemKind, Lifetime, LifetimeKind, LifetimeParamKind, Node,
|
||||
PolyTraitRef, PredicateOrigin, TraitFn, TraitItem, TraitItemKind, Ty, TyKind, WhereBoundPredicate, WherePredicate,
|
||||
WherePredicateKind, lang_items,
|
||||
};
|
||||
|
|
@ -218,7 +218,7 @@ fn check_fn_inner<'tcx>(
|
|||
for bound in pred.bounds {
|
||||
let mut visitor = RefVisitor::new(cx);
|
||||
walk_param_bound(&mut visitor, bound);
|
||||
if visitor.lts.iter().any(|lt| matches!(lt.res, LifetimeName::Param(_))) {
|
||||
if visitor.lts.iter().any(|lt| matches!(lt.kind, LifetimeKind::Param(_))) {
|
||||
return;
|
||||
}
|
||||
if let GenericBound::Trait(ref trait_ref) = *bound {
|
||||
|
|
@ -235,7 +235,7 @@ fn check_fn_inner<'tcx>(
|
|||
_ => None,
|
||||
});
|
||||
for bound in lifetimes {
|
||||
if bound.res != LifetimeName::Static && !bound.is_elided() {
|
||||
if bound.kind != LifetimeKind::Static && !bound.is_elided() {
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
|
@ -421,8 +421,8 @@ fn named_lifetime_occurrences(lts: &[Lifetime]) -> Vec<(LocalDefId, usize)> {
|
|||
}
|
||||
|
||||
fn named_lifetime(lt: &Lifetime) -> Option<LocalDefId> {
|
||||
match lt.res {
|
||||
LifetimeName::Param(id) if !lt.is_anonymous() => Some(id),
|
||||
match lt.kind {
|
||||
LifetimeKind::Param(id) if !lt.is_anonymous() => Some(id),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
|
@ -614,7 +614,7 @@ where
|
|||
|
||||
// for lifetimes as parameters of generics
|
||||
fn visit_lifetime(&mut self, lifetime: &'tcx Lifetime) {
|
||||
if let LifetimeName::Param(def_id) = lifetime.res
|
||||
if let LifetimeKind::Param(def_id) = lifetime.kind
|
||||
&& let Some(usages) = self.map.get_mut(&def_id)
|
||||
{
|
||||
usages.push(Usage {
|
||||
|
|
@ -826,7 +826,7 @@ fn report_elidable_lifetimes(
|
|||
.iter()
|
||||
.map(|<| cx.tcx.def_span(lt))
|
||||
.chain(usages.iter().filter_map(|usage| {
|
||||
if let LifetimeName::Param(def_id) = usage.res
|
||||
if let LifetimeKind::Param(def_id) = usage.kind
|
||||
&& elidable_lts.contains(&def_id)
|
||||
{
|
||||
return Some(usage.ident.span);
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@ use clippy_utils::source::SpanRangeExt;
|
|||
use clippy_utils::sugg::Sugg;
|
||||
use clippy_utils::visitors::contains_unsafe_block;
|
||||
use clippy_utils::{get_expr_use_or_unification_node, is_lint_allowed, path_def_id, path_to_local, std_or_core};
|
||||
use hir::LifetimeName;
|
||||
use hir::LifetimeKind;
|
||||
use rustc_abi::ExternAbi;
|
||||
use rustc_errors::{Applicability, MultiSpan};
|
||||
use rustc_hir::hir_id::{HirId, HirIdMap};
|
||||
|
|
@ -432,7 +432,7 @@ fn check_fn_args<'cx, 'tcx: 'cx>(
|
|||
}
|
||||
None
|
||||
}) {
|
||||
if let LifetimeName::Param(param_def_id) = lifetime.res
|
||||
if let LifetimeKind::Param(param_def_id) = lifetime.kind
|
||||
&& !lifetime.is_anonymous()
|
||||
&& fn_sig
|
||||
.output()
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ use rustc_hir::MatchSource::TryDesugar;
|
|||
use rustc_hir::def::{DefKind, Res};
|
||||
use rustc_hir::{
|
||||
AssocItemConstraint, BinOpKind, BindingMode, Block, BodyId, Closure, ConstArg, ConstArgKind, Expr, ExprField,
|
||||
ExprKind, FnRetTy, GenericArg, GenericArgs, HirId, HirIdMap, InlineAsmOperand, LetExpr, Lifetime, LifetimeName,
|
||||
ExprKind, FnRetTy, GenericArg, GenericArgs, HirId, HirIdMap, InlineAsmOperand, LetExpr, Lifetime, LifetimeKind,
|
||||
Pat, PatExpr, PatExprKind, PatField, PatKind, Path, PathSegment, PrimTy, QPath, Stmt, StmtKind, StructTailExpr,
|
||||
TraitBoundModifiers, Ty, TyKind, TyPat, TyPatKind,
|
||||
};
|
||||
|
|
@ -483,7 +483,7 @@ impl HirEqInterExpr<'_, '_, '_> {
|
|||
}
|
||||
|
||||
fn eq_lifetime(left: &Lifetime, right: &Lifetime) -> bool {
|
||||
left.res == right.res
|
||||
left.kind == right.kind
|
||||
}
|
||||
|
||||
fn eq_pat_field(&mut self, left: &PatField<'_>, right: &PatField<'_>) -> bool {
|
||||
|
|
@ -1245,8 +1245,8 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
|
|||
|
||||
pub fn hash_lifetime(&mut self, lifetime: &Lifetime) {
|
||||
lifetime.ident.name.hash(&mut self.s);
|
||||
std::mem::discriminant(&lifetime.res).hash(&mut self.s);
|
||||
if let LifetimeName::Param(param_id) = lifetime.res {
|
||||
std::mem::discriminant(&lifetime.kind).hash(&mut self.s);
|
||||
if let LifetimeKind::Param(param_id) = lifetime.kind {
|
||||
param_id.hash(&mut self.s);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -47,3 +47,22 @@ impl T for () {}
|
|||
pub fn foo() {
|
||||
().trait_method();
|
||||
}
|
||||
|
||||
// CHECK-LABEL: align_specified_twice_1
|
||||
// CHECK-SAME: align 64
|
||||
#[no_mangle]
|
||||
#[repr(align(32), align(64))]
|
||||
pub fn align_specified_twice_1() {}
|
||||
|
||||
// CHECK-LABEL: align_specified_twice_2
|
||||
// CHECK-SAME: align 128
|
||||
#[no_mangle]
|
||||
#[repr(align(128), align(32))]
|
||||
pub fn align_specified_twice_2() {}
|
||||
|
||||
// CHECK-LABEL: align_specified_twice_3
|
||||
// CHECK-SAME: align 256
|
||||
#[no_mangle]
|
||||
#[repr(align(32))]
|
||||
#[repr(align(256))]
|
||||
pub fn align_specified_twice_3() {}
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ pub enum Enum0 {
|
|||
B,
|
||||
}
|
||||
|
||||
// CHECK-LABEL: define noundef{{( range\(i8 [0-9]+, [0-9]+\))?}} i8 @match0(i8{{.+}}%0)
|
||||
// CHECK-LABEL: define{{( dso_local)?}} noundef{{( range\(i8 [0-9]+, [0-9]+\))?}} i8 @match0(i8{{.+}}%0)
|
||||
// CHECK-NEXT: start:
|
||||
// CHECK-NEXT: %[[IS_B:.+]] = icmp eq i8 %0, 2
|
||||
// CHECK-NEXT: %[[TRUNC:.+]] = and i8 %0, 1
|
||||
|
|
@ -37,7 +37,7 @@ pub enum Enum1 {
|
|||
C,
|
||||
}
|
||||
|
||||
// CHECK-LABEL: define noundef{{( range\(i8 [0-9]+, [0-9]+\))?}} i8 @match1(i8{{.+}}%0)
|
||||
// CHECK-LABEL: define{{( dso_local)?}} noundef{{( range\(i8 [0-9]+, [0-9]+\))?}} i8 @match1(i8{{.+}}%0)
|
||||
// CHECK-NEXT: start:
|
||||
// CHECK-NEXT: %[[REL_VAR:.+]] = add{{( nsw)?}} i8 %0, -2
|
||||
// CHECK-NEXT: %[[REL_VAR_WIDE:.+]] = zext i8 %[[REL_VAR]] to i64
|
||||
|
|
@ -98,7 +98,7 @@ pub enum Enum2 {
|
|||
E,
|
||||
}
|
||||
|
||||
// CHECK-LABEL: define noundef{{( range\(i8 [0-9]+, [0-9]+\))?}} i8 @match2(i8{{.+}}%0)
|
||||
// CHECK-LABEL: define{{( dso_local)?}} noundef{{( range\(i8 [0-9]+, [0-9]+\))?}} i8 @match2(i8{{.+}}%0)
|
||||
// CHECK-NEXT: start:
|
||||
// CHECK-NEXT: %[[REL_VAR:.+]] = add i8 %0, 2
|
||||
// CHECK-NEXT: %[[REL_VAR_WIDE:.+]] = zext i8 %[[REL_VAR]] to i64
|
||||
|
|
@ -121,7 +121,7 @@ pub fn match2(e: Enum2) -> u8 {
|
|||
// And make sure it works even if the niched scalar is a pointer.
|
||||
// (For example, that we don't try to `sub` on pointers.)
|
||||
|
||||
// CHECK-LABEL: define noundef{{( range\(i16 -?[0-9]+, -?[0-9]+\))?}} i16 @match3(ptr{{.+}}%0)
|
||||
// CHECK-LABEL: define{{( dso_local)?}} noundef{{( range\(i16 -?[0-9]+, -?[0-9]+\))?}} i16 @match3(ptr{{.+}}%0)
|
||||
// CHECK-NEXT: start:
|
||||
// CHECK-NEXT: %[[IS_NULL:.+]] = icmp eq ptr %0, null
|
||||
// CHECK-NEXT: br i1 %[[IS_NULL]]
|
||||
|
|
@ -145,7 +145,7 @@ pub enum MiddleNiche {
|
|||
E,
|
||||
}
|
||||
|
||||
// CHECK-LABEL: define noundef{{( range\(i8 -?[0-9]+, -?[0-9]+\))?}} i8 @match4(i8{{.+}}%0)
|
||||
// CHECK-LABEL: define{{( dso_local)?}} noundef{{( range\(i8 -?[0-9]+, -?[0-9]+\))?}} i8 @match4(i8{{.+}}%0)
|
||||
// CHECK-NEXT: start:
|
||||
// CHECK-NEXT: %[[REL_VAR:.+]] = add{{( nsw)?}} i8 %0, -2
|
||||
// CHECK-NEXT: %[[IS_NICHE:.+]] = icmp ult i8 %[[REL_VAR]], 5
|
||||
|
|
@ -449,7 +449,7 @@ pub enum HugeVariantIndex {
|
|||
Possible259,
|
||||
}
|
||||
|
||||
// CHECK-LABEL: define noundef{{( range\(i8 [0-9]+, [0-9]+\))?}} i8 @match5(i8{{.+}}%0)
|
||||
// CHECK-LABEL: define{{( dso_local)?}} noundef{{( range\(i8 [0-9]+, [0-9]+\))?}} i8 @match5(i8{{.+}}%0)
|
||||
// CHECK-NEXT: start:
|
||||
// CHECK-NEXT: %[[REL_VAR:.+]] = add{{( nsw)?}} i8 %0, -2
|
||||
// CHECK-NEXT: %[[REL_VAR_WIDE:.+]] = zext i8 %[[REL_VAR]] to i64
|
||||
|
|
|
|||
|
|
@ -66,7 +66,6 @@ error: unexpected `,` in pattern
|
|||
LL | let women, men: (Vec<Genome>, Vec<Genome>) = genomes.iter().cloned()
|
||||
| ^
|
||||
|
|
||||
= note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
|
||||
help: try adding parentheses to match on a tuple
|
||||
|
|
||||
LL | let (women, men): (Vec<Genome>, Vec<Genome>) = genomes.iter().cloned()
|
||||
|
|
|
|||
|
|
@ -4,7 +4,6 @@ error: path separator must be a double colon
|
|||
LL | a: Vec<foo::bar:A>,
|
||||
| ^
|
||||
|
|
||||
= note: if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
|
||||
help: use a double colon instead
|
||||
|
|
||||
LL | a: Vec<foo::bar::A>,
|
||||
|
|
|
|||
|
|
@ -6,9 +6,9 @@ macro transparent() {
|
|||
let transparent = 0;
|
||||
}
|
||||
#[rustc_macro_transparency = "semitransparent"]
|
||||
macro semitransparent() {
|
||||
struct SemiTransparent;
|
||||
let semitransparent = 0;
|
||||
macro semiopaque() {
|
||||
struct SemiOpaque;
|
||||
let semiopaque = 0;
|
||||
}
|
||||
#[rustc_macro_transparency = "opaque"]
|
||||
macro opaque() {
|
||||
|
|
@ -18,14 +18,14 @@ macro opaque() {
|
|||
|
||||
fn main() {
|
||||
transparent!();
|
||||
semitransparent!();
|
||||
semiopaque!();
|
||||
opaque!();
|
||||
|
||||
Transparent; // OK
|
||||
SemiTransparent; // OK
|
||||
SemiOpaque; // OK
|
||||
Opaque; //~ ERROR cannot find value `Opaque` in this scope
|
||||
|
||||
transparent; // OK
|
||||
semitransparent; //~ ERROR expected value, found macro `semitransparent`
|
||||
semiopaque; //~ ERROR expected value, found macro `semiopaque`
|
||||
opaque; //~ ERROR expected value, found macro `opaque`
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,17 +4,17 @@ error[E0425]: cannot find value `Opaque` in this scope
|
|||
LL | Opaque;
|
||||
| ^^^^^^ not found in this scope
|
||||
|
||||
error[E0423]: expected value, found macro `semitransparent`
|
||||
error[E0423]: expected value, found macro `semiopaque`
|
||||
--> $DIR/rustc-macro-transparency.rs:29:5
|
||||
|
|
||||
LL | struct SemiTransparent;
|
||||
| ----------------------- similarly named unit struct `SemiTransparent` defined here
|
||||
LL | struct SemiOpaque;
|
||||
| ------------------ similarly named unit struct `SemiOpaque` defined here
|
||||
...
|
||||
LL | semitransparent;
|
||||
| ^^^^^^^^^^^^^^^
|
||||
LL | semiopaque;
|
||||
| ^^^^^^^^^^
|
||||
| |
|
||||
| not a value
|
||||
| help: a unit struct with a similar name exists: `SemiTransparent`
|
||||
| help: a unit struct with a similar name exists (notice the capitalization): `SemiOpaque`
|
||||
|
||||
error[E0423]: expected value, found macro `opaque`
|
||||
--> $DIR/rustc-macro-transparency.rs:30:5
|
||||
|
|
|
|||
|
|
@ -24,5 +24,5 @@ crate0::{{expn1}}: parent: crate0::{{expn0}}, call_site_ctxt: #0, def_site_ctxt:
|
|||
|
||||
SyntaxContexts:
|
||||
#0: parent: #0, outer_mark: (crate0::{{expn0}}, Opaque)
|
||||
#1: parent: #0, outer_mark: (crate0::{{expn1}}, SemiTransparent)
|
||||
#1: parent: #0, outer_mark: (crate0::{{expn1}}, SemiOpaque)
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -6,7 +6,6 @@ LL | let _ = |A | B: E| ();
|
|||
| |
|
||||
| while parsing the body of this closure
|
||||
|
|
||||
= note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
|
||||
help: you might have meant to open the body of the closure
|
||||
|
|
||||
LL | let _ = |A | { B: E| ();
|
||||
|
|
|
|||
|
|
@ -49,24 +49,18 @@ error: expected one of `.`, `;`, `?`, `else`, or an operator, found `:`
|
|||
|
|
||||
LL | let _ = 0i32: i32: i32.count_ones();
|
||||
| ^ expected one of `.`, `;`, `?`, `else`, or an operator
|
||||
|
|
||||
= note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
|
||||
|
||||
error: expected one of `!`, `(`, `.`, `::`, `;`, `<`, `?`, or `else`, found `:`
|
||||
--> $DIR/issue-35813-postfix-after-cast.rs:43:21
|
||||
|
|
||||
LL | let _ = 0 as i32: i32.count_ones();
|
||||
| ^ expected one of 8 possible tokens
|
||||
|
|
||||
= note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
|
||||
|
||||
error: expected one of `.`, `;`, `?`, `else`, or an operator, found `:`
|
||||
--> $DIR/issue-35813-postfix-after-cast.rs:47:17
|
||||
|
|
||||
LL | let _ = 0i32: i32 as i32.count_ones();
|
||||
| ^ expected one of `.`, `;`, `?`, `else`, or an operator
|
||||
|
|
||||
= note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
|
||||
|
||||
error: cast cannot be followed by a method call
|
||||
--> $DIR/issue-35813-postfix-after-cast.rs:51:13
|
||||
|
|
@ -84,16 +78,12 @@ error: expected one of `.`, `;`, `?`, `else`, or an operator, found `:`
|
|||
|
|
||||
LL | let _ = 0i32: i32: i32 as u32 as i32.count_ones();
|
||||
| ^ expected one of `.`, `;`, `?`, `else`, or an operator
|
||||
|
|
||||
= note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
|
||||
|
||||
error: expected one of `.`, `;`, `?`, `else`, or an operator, found `:`
|
||||
--> $DIR/issue-35813-postfix-after-cast.rs:60:17
|
||||
|
|
||||
LL | let _ = 0i32: i32.count_ones(): u32;
|
||||
| ^ expected one of `.`, `;`, `?`, `else`, or an operator
|
||||
|
|
||||
= note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
|
||||
|
||||
error: cast cannot be followed by a method call
|
||||
--> $DIR/issue-35813-postfix-after-cast.rs:64:13
|
||||
|
|
@ -111,16 +101,12 @@ error: expected one of `.`, `;`, `?`, or `else`, found `:`
|
|||
|
|
||||
LL | let _ = 0 as i32.count_ones(): u32;
|
||||
| ^ expected one of `.`, `;`, `?`, or `else`
|
||||
|
|
||||
= note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
|
||||
|
||||
error: expected one of `.`, `;`, `?`, `else`, or an operator, found `:`
|
||||
--> $DIR/issue-35813-postfix-after-cast.rs:69:17
|
||||
|
|
||||
LL | let _ = 0i32: i32.count_ones() as u32;
|
||||
| ^ expected one of `.`, `;`, `?`, `else`, or an operator
|
||||
|
|
||||
= note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
|
||||
|
||||
error: cast cannot be followed by a method call
|
||||
--> $DIR/issue-35813-postfix-after-cast.rs:73:13
|
||||
|
|
@ -138,8 +124,6 @@ error: expected one of `.`, `;`, `?`, `else`, or an operator, found `:`
|
|||
|
|
||||
LL | let _ = 0i32: i32: i32.count_ones() as u32 as i32;
|
||||
| ^ expected one of `.`, `;`, `?`, `else`, or an operator
|
||||
|
|
||||
= note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
|
||||
|
||||
error: cast cannot be followed by a method call
|
||||
--> $DIR/issue-35813-postfix-after-cast.rs:82:13
|
||||
|
|
@ -262,8 +246,6 @@ error: expected identifier, found `:`
|
|||
|
|
||||
LL | drop_ptr: F();
|
||||
| ^ expected identifier
|
||||
|
|
||||
= note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
|
||||
|
||||
error: expected one of `!`, `.`, `::`, `;`, `?`, `{`, `}`, or an operator, found `:`
|
||||
--> $DIR/issue-35813-postfix-after-cast.rs:160:13
|
||||
|
|
|
|||
|
|
@ -4,7 +4,6 @@ error: expected one of `!`, `.`, `::`, `;`, `?`, `else`, `{`, or an operator, fo
|
|||
LL | let x = Tr<A, A:>;
|
||||
| ^ expected one of 8 possible tokens
|
||||
|
|
||||
= note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
|
||||
help: maybe write a path separator here
|
||||
|
|
||||
LL | let x = Tr<A, A::>;
|
||||
|
|
|
|||
|
|
@ -33,8 +33,6 @@ error: expected one of `.`, `;`, `?`, `else`, or an operator, found `:`
|
|||
|
|
||||
LL | let x = 5 > 2 ? { let x = vec![]: Vec<u16>; x } : { false };
|
||||
| ^ expected one of `.`, `;`, `?`, `else`, or an operator
|
||||
|
|
||||
= note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
|
||||
|
||||
error: Rust has no ternary operator
|
||||
--> $DIR/ternary_operator.rs:26:19
|
||||
|
|
|
|||
|
|
@ -11,8 +11,6 @@ error: expected one of `)`, `,`, `@`, `if`, or `|`, found `:`
|
|||
|
|
||||
LL | let a @ (b: u8);
|
||||
| ^ expected one of `)`, `,`, `@`, `if`, or `|`
|
||||
|
|
||||
= note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
|
||||
|
||||
error: expected one of `!`, `(`, `+`, `::`, `;`, `<`, or `=`, found `@`
|
||||
--> $DIR/nested-type-ascription-syntactically-invalid.rs:30:15
|
||||
|
|
|
|||
|
|
@ -60,11 +60,11 @@ SyntaxContexts:
|
|||
#0: parent: #0, outer_mark: (crate0::{{expn0}}, Opaque)
|
||||
#1: parent: #0, outer_mark: (crate0::{{expn1}}, Opaque)
|
||||
#2: parent: #0, outer_mark: (crate0::{{expn1}}, Transparent)
|
||||
#3: parent: #0, outer_mark: (crate0::{{expn2}}, SemiTransparent)
|
||||
#3: parent: #0, outer_mark: (crate0::{{expn2}}, SemiOpaque)
|
||||
#4: parent: #0, outer_mark: (crate0::{{expn3}}, Opaque)
|
||||
#5: parent: #3, outer_mark: (crate0::{{expn3}}, Transparent)
|
||||
#6: parent: #0, outer_mark: (crate0::{{expn3}}, SemiTransparent)
|
||||
#6: parent: #0, outer_mark: (crate0::{{expn3}}, SemiOpaque)
|
||||
#7: parent: #0, outer_mark: (crate0::{{expn4}}, Opaque)
|
||||
#8: parent: #4, outer_mark: (crate0::{{expn4}}, Transparent)
|
||||
#9: parent: #4, outer_mark: (crate0::{{expn4}}, SemiTransparent)
|
||||
#9: parent: #4, outer_mark: (crate0::{{expn4}}, SemiOpaque)
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -82,10 +82,10 @@ SyntaxContexts:
|
|||
#0: parent: #0, outer_mark: (crate0::{{expn0}}, Opaque)
|
||||
#1: parent: #0, outer_mark: (crate0::{{expn1}}, Opaque)
|
||||
#2: parent: #0, outer_mark: (crate0::{{expn1}}, Transparent)
|
||||
#3: parent: #0, outer_mark: (crate0::{{expn2}}, SemiTransparent)
|
||||
#3: parent: #0, outer_mark: (crate0::{{expn2}}, SemiOpaque)
|
||||
#4: parent: #3, outer_mark: (crate0::{{expn3}}, Opaque)
|
||||
#5: parent: #0, outer_mark: (crate0::{{expn3}}, Opaque)
|
||||
#6: parent: #0, outer_mark: (crate0::{{expn4}}, Opaque)
|
||||
#7: parent: #4, outer_mark: (crate0::{{expn4}}, Transparent)
|
||||
#8: parent: #5, outer_mark: (crate0::{{expn4}}, SemiTransparent)
|
||||
#8: parent: #5, outer_mark: (crate0::{{expn4}}, SemiOpaque)
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -4,7 +4,6 @@ error: path separator must be a double colon
|
|||
LL | fn fmt(&self, f: &mut fmt:Formatter) -> fmt::Result {
|
||||
| ^
|
||||
|
|
||||
= note: if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
|
||||
help: use a double colon instead
|
||||
|
|
||||
LL | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
|
|
|
|||
|
|
@ -3,8 +3,6 @@ error: expected one of `.`, `;`, `?`, `else`, or an operator, found `:`
|
|||
|
|
||||
LL | let _ = 0: i32;
|
||||
| ^ expected one of `.`, `;`, `?`, `else`, or an operator
|
||||
|
|
||||
= note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
|
||||
|
||||
error: aborting due to 1 previous error
|
||||
|
||||
|
|
|
|||
|
|
@ -4,7 +4,6 @@ error: path separator must be a double colon
|
|||
LL | a: foo:A,
|
||||
| ^
|
||||
|
|
||||
= note: if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
|
||||
help: use a double colon instead
|
||||
|
|
||||
LL | a: foo::A,
|
||||
|
|
@ -16,7 +15,6 @@ error: path separator must be a double colon
|
|||
LL | b: foo::bar:B,
|
||||
| ^
|
||||
|
|
||||
= note: if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
|
||||
help: use a double colon instead
|
||||
|
|
||||
LL | b: foo::bar::B,
|
||||
|
|
|
|||
|
|
@ -4,7 +4,6 @@ error: path separator must be a double colon
|
|||
LL | let _ = Box:new("foo".to_string());
|
||||
| ^
|
||||
|
|
||||
= note: if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
|
||||
help: use a double colon instead
|
||||
|
|
||||
LL | let _ = Box::new("foo".to_string());
|
||||
|
|
|
|||
|
|
@ -4,7 +4,6 @@ error: expected one of `(`, `.`, `::`, `;`, `?`, `else`, or an operator, found `
|
|||
LL | let _ = vec![Ok(2)].into_iter().collect:<Result<Vec<_>,_>>()?;
|
||||
| ^ expected one of 7 possible tokens
|
||||
|
|
||||
= note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
|
||||
help: maybe write a path separator here
|
||||
|
|
||||
LL | let _ = vec![Ok(2)].into_iter().collect::<Result<Vec<_>,_>>()?;
|
||||
|
|
|
|||
|
|
@ -4,7 +4,6 @@ error: path separator must be a double colon
|
|||
LL | std:io::stdin();
|
||||
| ^
|
||||
|
|
||||
= note: if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
|
||||
help: use a double colon instead
|
||||
|
|
||||
LL | std::io::stdin();
|
||||
|
|
|
|||
|
|
@ -4,7 +4,6 @@ error: path separator must be a double colon
|
|||
LL | let _ = Option:Some("");
|
||||
| ^
|
||||
|
|
||||
= note: if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
|
||||
help: use a double colon instead
|
||||
|
|
||||
LL | let _ = Option::Some("");
|
||||
|
|
|
|||
|
|
@ -4,7 +4,6 @@ error: path separator must be a double colon
|
|||
LL | let _ = Option:Some(vec![0, 1]);
|
||||
| ^
|
||||
|
|
||||
= note: if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
|
||||
help: use a double colon instead
|
||||
|
|
||||
LL | let _ = Option::Some(vec![0, 1]);
|
||||
|
|
|
|||
|
|
@ -4,7 +4,6 @@ error: path separator must be a double colon
|
|||
LL | println!("{}", std::mem:size_of::<BTreeMap<u32, u32>>());
|
||||
| ^
|
||||
|
|
||||
= note: if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
|
||||
help: use a double colon instead
|
||||
|
|
||||
LL | println!("{}", std::mem::size_of::<BTreeMap<u32, u32>>());
|
||||
|
|
|
|||
|
|
@ -4,7 +4,6 @@ error: path separator must be a double colon
|
|||
LL | let _: usize = std::mem:size_of::<u32>();
|
||||
| ^
|
||||
|
|
||||
= note: if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
|
||||
help: use a double colon instead
|
||||
|
|
||||
LL | let _: usize = std::mem::size_of::<u32>();
|
||||
|
|
|
|||
|
|
@ -4,7 +4,6 @@ error: expected identifier, found `:`
|
|||
LL | _foo: i32 = 4;
|
||||
| ^ expected identifier
|
||||
|
|
||||
= note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
|
||||
help: you might have meant to introduce a new binding
|
||||
|
|
||||
LL | let _foo: i32 = 4;
|
||||
|
|
|
|||
|
|
@ -4,7 +4,6 @@ error: statements are terminated with a semicolon
|
|||
LL | println!("test"):
|
||||
| ^
|
||||
|
|
||||
= note: if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
|
||||
help: use a semicolon instead
|
||||
|
|
||||
LL - println!("test"):
|
||||
|
|
|
|||
|
|
@ -33,8 +33,6 @@ error: expected identifier, found `:`
|
|||
|
|
||||
LL | S .. S: S;
|
||||
| ^ expected identifier
|
||||
|
|
||||
= note: type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
|
||||
|
||||
error: expected one of `.`, `;`, `?`, `}`, or an operator, found `:`
|
||||
--> $DIR/type-ascription-precedence.rs:53:13
|
||||
|
|
|
|||
|
|
@ -4,7 +4,6 @@ error: statements are terminated with a semicolon
|
|||
LL | f() :
|
||||
| ^
|
||||
|
|
||||
= note: if you meant to annotate an expression with a type, the type ascription syntax has been removed, see issue #101728 <https://github.com/rust-lang/rust/issues/101728>
|
||||
help: use a semicolon instead
|
||||
|
|
||||
LL - f() :
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue