Rustup (#17447)

r? @ghost

changelog: none

Author: flip1995

clippy_lints/src/approx_const.rs

@@ -75,7 +75,7 @@ impl ApproxConstant {
 }
 
 impl LateLintPass<'_> for ApproxConstant {
-    fn check_lit(&mut self, cx: &LateContext<'_>, _hir_id: HirId, lit: Lit, _negated: bool) {
+    fn check_lit(&mut self, cx: &LateContext<'_>, _hir_id: HirId, lit: Lit, _is_negated_pat: bool) {
         match lit.node {
             LitKind::Float(s, LitFloatType::Suffixed(fty)) => match fty {
                 FloatTy::F16 => self.check_known_consts(cx, lit.span, s, "f16"),

clippy_lints/src/attrs/duplicated_attributes.rs

@@ -43,21 +43,12 @@ fn check_duplicated_attr(
     };
     if let Some(ident) = attr.ident() {
         let name = ident.name;
-        if name == sym::doc || name == sym::cfg_attr_trace || name == sym::rustc_on_unimplemented || name == sym::reason
-        {
+        if name == sym::doc || name == sym::rustc_on_unimplemented || name == sym::reason {
             // FIXME: Would be nice to handle `cfg_attr` as well. Only problem is to check that cfg
             // conditions are the same.
             // `#[rustc_on_unimplemented]` contains duplicated subattributes, that's expected.
             return;
         }
-        if let Some(direct_parent) = parent.last()
-            && *direct_parent == sym::cfg_trace
-            && [sym::all, sym::not, sym::any].contains(&name)
-        {
-            // FIXME: We don't correctly check `cfg`s for now, so if it's more complex than just a one
-            // level `cfg`, we leave.
-            return;
-        }
     }
     if let Some(value) = attr.value_str() {
         emit_if_duplicated(

clippy_lints/src/attrs/mixed_attributes_style.rs

@@ -1,6 +1,6 @@
 use super::MIXED_ATTRIBUTES_STYLE;
 use clippy_utils::diagnostics::span_lint;
-use rustc_ast::{AttrKind, AttrStyle, Attribute};
+use rustc_ast::{AttrKind, AttrStyle, Attribute, SyntheticAttr};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_lint::{EarlyContext, LintContext as _};
 use rustc_span::source_map::SourceMap;
@@ -12,6 +12,8 @@ enum SimpleAttrKind {
     Doc,
     /// A normal attribute, with its name symbols.
     Normal(Vec<Symbol>),
+    CfgTrace,
+    CfgAttrTrace,
 }
 
 impl From<&AttrKind> for SimpleAttrKind {
@@ -27,6 +29,10 @@ impl From<&AttrKind> for SimpleAttrKind {
                     .collect::<Vec<_>>();
                 Self::Normal(path_symbols)
             },
+            AttrKind::Synthetic(synthetic) => match &**synthetic {
+                SyntheticAttr::CfgTrace(_) => Self::CfgTrace,
+                SyntheticAttr::CfgAttrTrace => Self::CfgAttrTrace,
+            },
             AttrKind::DocComment(..) => Self::Doc,
         }
     }

clippy_lints/src/attrs/mod.rs

@@ -17,7 +17,7 @@ use clippy_config::Conf;
 use clippy_utils::check_clippy_attr;
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::msrvs::{self, Msrv, MsrvStack};
-use rustc_ast::{self as ast, AttrArgs, AttrItemKind, AttrKind, Attribute, MetaItemInner, MetaItemKind};
+use rustc_ast::{self as ast, AttrArgs, AttrKind, Attribute, MetaItemInner, MetaItemKind};
 use rustc_hir::{ImplItem, ImplItemKind, Item, ItemKind, TraitFn, TraitItem, TraitItemKind};
 use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext as _};
 use rustc_session::impl_lint_pass;
@@ -614,12 +614,8 @@ impl EarlyLintPass for PostExpansionEarlyAttributes {
         }
 
         if attr.has_name(sym::ignore)
-            && match &attr.kind {
-                AttrKind::Normal(normal_attr) => {
-                    !matches!(normal_attr.item.args, AttrItemKind::Unparsed(AttrArgs::Eq { .. }))
-                },
-                AttrKind::DocComment(..) => true,
-            }
+            && let AttrKind::Normal(normal_attr) = &attr.kind
+            && !matches!(normal_attr.item.args, AttrArgs::Eq { .. })
         {
             span_lint_and_help(
                 cx,

clippy_lints/src/attrs/should_panic_without_expect.rs

@@ -2,19 +2,19 @@ use super::{Attribute, SHOULD_PANIC_WITHOUT_EXPECT};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use rustc_ast::token::{Token, TokenKind};
 use rustc_ast::tokenstream::TokenTree;
-use rustc_ast::{AttrArgs, AttrItemKind, AttrKind};
+use rustc_ast::{AttrArgs, AttrKind};
 use rustc_errors::Applicability;
 use rustc_lint::EarlyContext;
 use rustc_span::sym;
 
 pub(super) fn check(cx: &EarlyContext<'_>, attr: &Attribute) {
     if let AttrKind::Normal(normal_attr) = &attr.kind {
-        if let AttrItemKind::Unparsed(AttrArgs::Eq { .. }) = &normal_attr.item.args {
+        if let AttrArgs::Eq { .. } = &normal_attr.item.args {
             // `#[should_panic = ".."]` found, good
             return;
         }
 
-        if let AttrItemKind::Unparsed(AttrArgs::Delimited(args)) = &normal_attr.item.args
+        if let AttrArgs::Delimited(args) = &normal_attr.item.args
             && let mut tt_iter = args.tokens.iter()
             && let Some(TokenTree::Token(
                 Token {

clippy_lints/src/casts/confusing_method_to_numeric_cast.rs

@@ -65,7 +65,8 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
 
     if let ty::FnDef(def_id, generics) = cast_from.kind()
         && let Some(method_name) = cx.tcx.opt_item_name(*def_id)
-        && let Some((const_name, ty_name)) = get_const_name_and_ty_name(cx, method_name, *def_id, generics.as_slice())
+        && let Some((const_name, ty_name)) =
+            get_const_name_and_ty_name(cx, method_name, *def_id, generics.no_bound_vars().unwrap().as_slice())
     {
         let mut applicability = Applicability::MaybeIncorrect;
         let from_snippet = snippet_with_applicability(cx, cast_expr.span, "..", &mut applicability);

clippy_lints/src/cfg_not_test.rs

@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_ast::attr::data_structures::CfgEntry;
-use rustc_ast::{AttrItemKind, EarlyParsedAttribute};
+use rustc_ast::{AttrKind, SyntheticAttr};
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::declare_lint_pass;
 use rustc_span::sym;
@@ -34,23 +34,20 @@ declare_lint_pass!(CfgNotTest => [CFG_NOT_TEST]);
 
 impl EarlyLintPass for CfgNotTest {
     fn check_attribute(&mut self, cx: &EarlyContext<'_>, attr: &rustc_ast::Attribute) {
-        if attr.has_name(sym::cfg_trace) {
-            let AttrItemKind::Parsed(EarlyParsedAttribute::CfgTrace(cfg)) = &attr.get_normal_item().args else {
-                unreachable!()
-            };
-
-            if contains_not_test(cfg, false) {
-                span_lint_and_then(
-                    cx,
-                    CFG_NOT_TEST,
-                    attr.span,
-                    "code is excluded from test builds",
-                    |diag| {
-                        diag.help("consider not excluding any code from test builds");
-                        diag.note_once("this could increase code coverage despite not actually being tested");
-                    },
-                );
-            }
+        if let AttrKind::Synthetic(synthetic) = &attr.kind
+            && let SyntheticAttr::CfgTrace(cfg) = &**synthetic
+            && contains_not_test(cfg, false)
+        {
+            span_lint_and_then(
+                cx,
+                CFG_NOT_TEST,
+                attr.span,
+                "code is excluded from test builds",
+                |diag| {
+                    diag.help("consider not excluding any code from test builds");
+                    diag.note_once("this could increase code coverage despite not actually being tested");
+                },
+            );
         }
     }
 }

clippy_lints/src/dereference.rs

@@ -902,6 +902,10 @@ impl TyCoercionStability {
                 | TyKind::TraitObject(..)
                 | TyKind::InferDelegation(..)
                 | TyKind::Err(_) => Self::Reborrow,
+                TyKind::View(ty, _) => {
+                    // FIXME(scrabsha): what are the semantics of view types here?
+                    Self::for_hir_ty(ty)
+                },
                 TyKind::UnsafeBinder(..) => Self::None,
             };
         }

clippy_lints/src/doc/include_in_doc_without_cfg.rs

@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_opt;
-use rustc_ast::{AttrArgs, AttrItemKind, AttrKind, AttrStyle, Attribute};
+use rustc_ast::{AttrArgs, AttrKind, AttrStyle, Attribute};
 use rustc_errors::Applicability;
 use rustc_lint::EarlyContext;
 
@@ -9,9 +9,9 @@ use super::DOC_INCLUDE_WITHOUT_CFG;
 pub fn check(cx: &EarlyContext<'_>, attrs: &[Attribute]) {
     for attr in attrs {
         if !attr.span.from_expansion()
-            && let AttrKind::Normal(ref item) = attr.kind
+            && let AttrKind::Normal(ref normal) = attr.kind
             && attr.doc_str().is_some()
-            && let AttrItemKind::Unparsed(AttrArgs::Eq { expr: meta, .. }) = &item.item.args
+            && let AttrArgs::Eq { expr: meta, .. } = &normal.item.args
             && !attr.span.contains(meta.span)
             // Since the `include_str` is already expanded at this point, we can only take the
             // whole attribute snippet and then modify for our suggestion.

clippy_lints/src/doc/mod.rs

@@ -1246,7 +1246,8 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
                     containers.pop();
                 }
                 if check_doc_markdown {
-                    if ticks_unbalanced && let Some(span) = fragments.span(cx, paragraph_range.clone()) {
+                    if ticks_unbalanced && let Some(span) = fragments.span(cx, paragraph_range.clone())
+                    .or_else(|| span_of_fragments(fragments.fragments)) {
                         span_lint_and_help(
                             cx,
                             DOC_MARKDOWN,
@@ -1259,13 +1260,7 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
                     } else {
                         for (text, range, assoc_code_level) in text_to_check.drain(..) {
                             markdown::check(
-                                cx,
-                                valid_idents,
-                                &text,
-                                &fragments,
-                                range,
-                                assoc_code_level,
-                                blockquote_level,
+                                cx, valid_idents, &text, &fragments, range, assoc_code_level, blockquote_level
                             );
                         }
                     }