Auto merge of #159610 - JonathanBrouwer:rollup-Wil0K5d, r=JonathanBrouwer

Rollup of 18 pull requests

Successful merges:

 - #159600 (`rust-analyzer` subtree update)
 - #158046 (proc_macro: preserve file module spans for inner attrs)
 - #159000 (Small cleanups to the incr comp session code)
 - #159189 (Account for type alias projections in E0308 "expected/found" shortening logic)
 - #159449 (Enable single Location to issue multiple borrows)
 - #159544 (Suggest valid command-line crate names)
 - #159587 (Improve `AttrItem::span`)
 - #159594 (feat(rustc_hir_typeck): suggest `impl Fn` return for capturing closures)
 - #159597 (std: use `arc4random_buf` from libc)
 - #159599 (Resolver: Record at least 1 ambiguous trait if main decl is not a trait.)
 - #158061 (Make `pin!()` more foolproof.)
 - #159460 (Do not mark unnormalized const aliases as rigid when normalizing param env)
 - #159529 (Add regression test for nested replacement ranges in `collect_tokens`)
 - #159571 (Remove unused bundled library lookup for the local crate)
 - #159585 (Minor `TokenStream` improvements)
 - #159586 (Separate `InterpCx` usage by `ConstAnalysis` phases)
 - #159602 (Remove `ItemLike`)
 - #159603 (Clarify `push_stream`/`push_tree`)

Failed merges:

 - #159590 (Remove some dead code)

Author: bors

compiler/rustc_ast/src/ast.rs

@@ -3445,6 +3445,7 @@ impl NormalAttr {
                 unsafety: Safety::Default,
                 path: Path::from_ident(ident),
                 args: AttrArgs::Empty,
+                span: ident.span,
             },
             tokens: None,
         }
@@ -3456,6 +3457,15 @@ pub struct AttrItem {
     pub unsafety: Safety,
     pub path: Path,
     pub args: AttrArgs,
+    /// The span of the entire attr item. For parse attrs this excludes `#[`/`]`. E.g.:
+    /// ```ignore (illustrative)
+    /// #[foo(bar)]
+    ///   ^^^^^^^^
+    /// #[unsafe(no_mangle)]
+    ///   ^^^^^^^^^^^^^^^^^
+    /// ```
+    /// For internally constructed spans (`mk_attr_*`) the exact meaning may differ.
+    pub span: Span,
 }
 
 /// Synthetic attributes are inserted by the compiler. They cannot be written in source code, and
@@ -4398,7 +4408,7 @@ mod size_asserts {
     static_assert_size!(MetaItem, 80);
     static_assert_size!(MetaItemKind, 40);
     static_assert_size!(MetaItemLit, 40);
-    static_assert_size!(NormalAttr, 72);
+    static_assert_size!(NormalAttr, 80);
     static_assert_size!(Param, 40);
     static_assert_size!(Pat, 64);
     static_assert_size!(PatKind, 48);

compiler/rustc_ast/src/attr/mod.rs

@@ -315,7 +315,7 @@ impl Attribute {
 
                 // #[deprecated = "..."]
                 if let Some(s) = meta.value_str() {
-                    return Some(Ident { name: s, span: meta.span() });
+                    return Some(Ident { name: s, span: meta.span });
                 }
 
                 // #[deprecated(note = "...")]
@@ -342,10 +342,6 @@ impl AttrItem {
         if let [seg] = &*self.path.segments { Some(seg.ident.name) } else { None }
     }
 
-    pub fn span(&self) -> Span {
-        self.args.span().map_or(self.path.span, |args_span| self.path.span.to(args_span))
-    }
-
     pub fn meta_item_list(&self) -> Option<ThinVec<MetaItemInner>> {
         match &self.args {
             AttrArgs::Delimited(args) if args.delim == Delimiter::Parenthesis => {
@@ -794,6 +790,8 @@ fn mk_attr_tokens(
     LazyAttrTokenStream::new_direct(AttrTokenStream::new(tokens))
 }
 
+// `span` is used for the `Attribute` and everything within it (except for any span within
+// `unsafety`).
 pub fn mk_attr_word(
     g: &AttrIdGenerator,
     style: AttrStyle,
@@ -814,9 +812,11 @@ pub fn mk_attr_word(
         span,
     ));
 
-    mk_attr_from_item(g, AttrItem { unsafety, path, args }, tokens, style, span)
+    mk_attr_from_item(g, AttrItem { unsafety, path, args, span }, tokens, style, span)
 }
 
+// `span` is used for the `Attribute` and everything within it (except for any span within
+// `unsafety`).
 pub fn mk_attr_nested_word(
     g: &AttrIdGenerator,
     style: AttrStyle,
@@ -855,9 +855,11 @@ pub fn mk_attr_nested_word(
         span,
     ));
 
-    mk_attr_from_item(g, AttrItem { unsafety, path, args: attr_args }, tokens, style, span)
+    mk_attr_from_item(g, AttrItem { unsafety, path, args: attr_args, span }, tokens, style, span)
 }
 
+// `span` is used for the `Attribute` and everything within it (except for any span within
+// `unsafety`).
 pub fn mk_attr_name_value_str(
     g: &AttrIdGenerator,
     style: AttrStyle,
@@ -891,7 +893,7 @@ pub fn mk_attr_name_value_str(
         span,
     ));
 
-    mk_attr_from_item(g, AttrItem { unsafety, path, args }, tokens, style, span)
+    mk_attr_from_item(g, AttrItem { unsafety, path, args, span }, tokens, style, span)
 }
 
 pub fn filter_by_name(attrs: &[Attribute], name: Symbol) -> impl Iterator<Item = &Attribute> {

compiler/rustc_ast/src/tokenstream.rs

@@ -662,13 +662,12 @@ impl TokenStream {
 
     // If `vec` is not empty, try to glue `tt` onto its last token. The return
     // value indicates if gluing took place.
-    fn try_glue_to_last(vec: &mut Vec<TokenTree>, tt: &TokenTree) -> bool {
+    fn try_glue_to_last(vec: &mut [TokenTree], tt: &TokenTree) -> bool {
         if let Some(TokenTree::Token(last_tok, Spacing::Joint | Spacing::JointHidden)) = vec.last()
             && let TokenTree::Token(tok, spacing) = tt
             && let Some(glued_tok) = last_tok.glue(tok)
         {
-            // ...then overwrite the last token tree in `vec` with the
-            // glued token, and skip the first token tree from `stream`.
+            // ...then overwrite the last token tree in `vec` with the glued token.
             *vec.last_mut().unwrap() = TokenTree::Token(glued_tok, *spacing);
             true
         } else {
@@ -678,7 +677,11 @@ impl TokenStream {
 
     /// Push `tt` onto the end of the stream, possibly gluing it to the last
     /// token. Uses `make_mut` to maximize efficiency.
-    pub fn push_tree(&mut self, tt: TokenTree) {
+    ///
+    /// This is intended for specific proc macro use. For general `TokenStream`
+    /// construction within the compiler just build a `Vec<TokenTree>` with
+    /// normal `Vec` operations and then do `TokenStream::new`.
+    pub fn push_tree_with_gluing(&mut self, tt: TokenTree) {
         let vec_mut = Arc::make_mut(&mut self.0);
 
         if Self::try_glue_to_last(vec_mut, &tt) {
@@ -691,7 +694,11 @@ impl TokenStream {
     /// Push `stream` onto the end of the stream, possibly gluing the first
     /// token tree to the last token. (No other token trees will be glued.)
     /// Uses `make_mut` to maximize efficiency.
-    pub fn push_stream(&mut self, stream: TokenStream) {
+    ///
+    /// This is intended for specific proc macro use. For general `TokenStream`
+    /// construction within the compiler just build a `Vec<TokenTree>` with
+    /// normal `Vec` operations and then do `TokenStream::new`.
+    pub fn push_stream_with_gluing(&mut self, stream: TokenStream) {
         let vec_mut = Arc::make_mut(&mut self.0);
 
         let stream_iter = stream.0.iter().cloned();
@@ -707,10 +714,6 @@ impl TokenStream {
         }
     }
 
-    pub fn chunks(&self, chunk_size: usize) -> core::slice::Chunks<'_, TokenTree> {
-        self.0.chunks(chunk_size)
-    }
-
     /// Desugar doc comments like `/// foo` in the stream into `#[doc =
     /// r"foo"]`. Modifies the `TokenStream` via `Arc::make_mut`, but as little
     /// as possible.
@@ -845,9 +848,7 @@ impl FromIterator<TokenTree> for TokenStream {
 
 impl StableHash for TokenStream {
     fn stable_hash<Hcx: StableHashCtxt>(&self, hcx: &mut Hcx, hasher: &mut StableHasher) {
-        for sub_tt in self.iter() {
-            sub_tt.stable_hash(hcx, hasher);
-        }
+        self.0.as_slice().stable_hash(hcx, hasher);
     }
 }
 

compiler/rustc_attr_parsing/src/attributes/cfg.rs

@@ -406,7 +406,7 @@ fn parse_cfg_attr_internal<'a>(
     let cfg_predicate = AttributeParser::parse_single_args(
         sess,
         attribute.span,
-        attribute.get_normal_item().span(),
+        attribute.get_normal_item().span,
         attribute.style,
         AttrPath { segments: attribute.path().into_boxed_slice(), span: attribute.span },
         Some(attribute.get_normal_item().unsafety),

compiler/rustc_attr_parsing/src/interface.rs

@@ -172,7 +172,7 @@ impl<'sess> AttributeParser<'sess> {
         Self::parse_single_args(
             sess,
             attr.span,
-            attr_item.span(),
+            attr_item.span,
             attr.style,
             path,
             Some(attr_item.unsafety),
@@ -334,7 +334,7 @@ impl<'sess> AttributeParser<'sess> {
                     let attr_path = AttrPath::from_ast(&n.item.path, lower_span);
                     let parts =
                         n.item.path.segments.iter().map(|seg| seg.ident.name).collect::<Vec<_>>();
-                    let inner_span = lower_span(n.item.span());
+                    let inner_span = lower_span(n.item.span);
 
                     if let Some(accept) = ATTRIBUTE_PARSERS.accepters.get(parts.as_slice()) {
                         self.check_attribute_safety(