Auto merge of #153783 - JonathanBrouwer:rollup-xAG0lwn, r=JonathanBrouwer

Rollup of 5 pull requests

Successful merges:

 - #153705 (Always generate generics in delegation that match trait in trait impl scenario)
 - #153751 (Detect existing turbofish on method calls to suppress useless suggestion)
 - #153780 (Remove `MTLock`)
 - #151572 (Fix Hexagon ABI calling convention for small aggregates)
 - #153725 (Fix that `./x test --no-doc` actually keeps the same behaviour for backwards compatability)

Author: bors

compiler/rustc_ast_lowering/src/delegation.rs

@@ -725,9 +725,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
         result: &mut GenericsGenerationResult<'hir>,
         add_lifetimes: bool,
     ) -> hir::PathSegment<'hir> {
+        let details = result.generics.args_propagation_details();
+
         // The first condition is needed when there is SelfAndUserSpecified case,
         // we don't want to propagate generics params in this situation.
-        let segment = if !result.generics.is_user_specified()
+        let segment = if details.should_propagate
             && let Some(args) = result
                 .generics
                 .into_hir_generics(self, item_id, span)
@@ -738,7 +740,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             segment.clone()
         };
 
-        if result.generics.is_user_specified() {
+        if details.use_args_in_sig_inheritance {
             result.args_segment_id = Some(segment.hir_id);
         }
 

compiler/rustc_ast_lowering/src/delegation/generics.rs

@@ -20,6 +20,10 @@ pub(super) enum DelegationGenerics<T> {
     /// In free-to-trait reuse, when user specified args for trait `reuse Trait::<i32>::foo;`
     /// in this case we need to both generate `Self` and process user args.
     SelfAndUserSpecified(Option<T>),
+    /// In delegations from trait impl to other entities like free functions or trait functions,
+    /// we want to generate a function whose generics matches generics of signature function
+    /// in trait.
+    TraitImpl(Option<T>, bool /* Has user-specified args */),
 }
 
 /// Used for storing either AST generics or their lowered HIR version. Firstly we obtain
@@ -48,12 +52,29 @@ pub(super) struct GenericsGenerationResults<'hir> {
     pub(super) child: GenericsGenerationResult<'hir>,
 }
 
+pub(super) struct GenericArgsPropagationDetails {
+    pub(super) should_propagate: bool,
+    pub(super) use_args_in_sig_inheritance: bool,
+}
+
 impl<T> DelegationGenerics<T> {
-    fn is_user_specified(&self) -> bool {
-        matches!(
-            self,
-            DelegationGenerics::UserSpecified | DelegationGenerics::SelfAndUserSpecified { .. }
-        )
+    fn args_propagation_details(&self) -> GenericArgsPropagationDetails {
+        match self {
+            DelegationGenerics::UserSpecified | DelegationGenerics::SelfAndUserSpecified { .. } => {
+                GenericArgsPropagationDetails {
+                    should_propagate: false,
+                    use_args_in_sig_inheritance: true,
+                }
+            }
+            DelegationGenerics::TraitImpl(_, user_specified) => GenericArgsPropagationDetails {
+                should_propagate: !*user_specified,
+                use_args_in_sig_inheritance: false,
+            },
+            DelegationGenerics::Default(_) => GenericArgsPropagationDetails {
+                should_propagate: true,
+                use_args_in_sig_inheritance: false,
+            },
+        }
     }
 }
 
@@ -77,6 +98,12 @@ impl<'hir> HirOrAstGenerics<'hir> {
                 DelegationGenerics::SelfAndUserSpecified(generics) => {
                     DelegationGenerics::SelfAndUserSpecified(generics.as_mut().map(process_params))
                 }
+                DelegationGenerics::TraitImpl(generics, user_specified) => {
+                    DelegationGenerics::TraitImpl(
+                        generics.as_mut().map(process_params),
+                        *user_specified,
+                    )
+                }
             };
 
             *self = HirOrAstGenerics::Hir(hir_generics);
@@ -91,7 +118,8 @@ impl<'hir> HirOrAstGenerics<'hir> {
             HirOrAstGenerics::Hir(hir_generics) => match hir_generics {
                 DelegationGenerics::UserSpecified => hir::Generics::empty(),
                 DelegationGenerics::Default(generics)
-                | DelegationGenerics::SelfAndUserSpecified(generics) => {
+                | DelegationGenerics::SelfAndUserSpecified(generics)
+                | DelegationGenerics::TraitImpl(generics, _) => {
                     generics.unwrap_or(hir::Generics::empty())
                 }
             },
@@ -111,17 +139,18 @@ impl<'hir> HirOrAstGenerics<'hir> {
             HirOrAstGenerics::Hir(hir_generics) => match hir_generics {
                 DelegationGenerics::UserSpecified => None,
                 DelegationGenerics::Default(generics)
-                | DelegationGenerics::SelfAndUserSpecified(generics) => generics.map(|generics| {
+                | DelegationGenerics::SelfAndUserSpecified(generics)
+                | DelegationGenerics::TraitImpl(generics, _) => generics.map(|generics| {
                     ctx.create_generics_args_from_params(generics.params, add_lifetimes, span)
                 }),
             },
         }
     }
 
-    pub(super) fn is_user_specified(&self) -> bool {
+    pub(super) fn args_propagation_details(&self) -> GenericArgsPropagationDetails {
         match self {
-            HirOrAstGenerics::Ast(ast_generics) => ast_generics.is_user_specified(),
-            HirOrAstGenerics::Hir(hir_generics) => hir_generics.is_user_specified(),
+            HirOrAstGenerics::Ast(ast_generics) => ast_generics.args_propagation_details(),
+            HirOrAstGenerics::Hir(hir_generics) => hir_generics.args_propagation_details(),
         }
     }
 }
@@ -215,10 +244,29 @@ impl<'hir> LoweringContext<'_, 'hir> {
         item_id: NodeId,
         span: Span,
     ) -> GenericsGenerationResults<'hir> {
-        let delegation_in_free_ctx = !matches!(
-            self.tcx.def_kind(self.tcx.local_parent(self.local_def_id(item_id))),
-            DefKind::Trait | DefKind::Impl { .. }
-        );
+        let delegation_parent_kind =
+            self.tcx.def_kind(self.tcx.local_parent(self.local_def_id(item_id)));
+
+        let segments = &delegation.path.segments;
+        let len = segments.len();
+        let child_user_specified = segments[len - 1].args.is_some();
+
+        // If we are in trait impl always generate function whose generics matches
+        // those that are defined in trait.
+        if matches!(delegation_parent_kind, DefKind::Impl { of_trait: true }) {
+            // Considering parent generics, during signature inheritance
+            // we will take those args that are in trait impl header trait ref.
+            let parent = GenericsGenerationResult::new(DelegationGenerics::Default(None));
+
+            let generics = self.get_fn_like_generics(root_fn_id, span);
+            let child = DelegationGenerics::TraitImpl(generics, child_user_specified);
+            let child = GenericsGenerationResult::new(child);
+
+            return GenericsGenerationResults { parent, child };
+        }
+
+        let delegation_in_free_ctx =
+            !matches!(delegation_parent_kind, DefKind::Trait | DefKind::Impl { .. });
 
         let root_function_in_trait =
             matches!(self.tcx.def_kind(self.tcx.parent(root_fn_id)), DefKind::Trait);
@@ -234,9 +282,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
             )
         };
 
-        let segments = &delegation.path.segments;
-        let len = segments.len();
-
         let can_add_generics_to_parent = len >= 2
             && self.get_resolution_id(segments[len - 2].id).is_some_and(|def_id| {
                 matches!(self.tcx.def_kind(def_id), DefKind::Trait | DefKind::TraitAlias)
@@ -256,7 +301,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             DelegationGenerics::Default(None)
         };
 
-        let child_generics = if segments[len - 1].args.is_some() {
+        let child_generics = if child_user_specified {
             DelegationGenerics::UserSpecified
         } else {
             DelegationGenerics::Default(self.get_fn_like_generics(root_fn_id, span))

compiler/rustc_data_structures/src/sync.rs

@@ -21,11 +21,6 @@
 //! | `Lock<T>`               | `RefCell<T>`        | `RefCell<T>` or                 |
 //! |                         |                     | `parking_lot::Mutex<T>`         |
 //! | `RwLock<T>`             | `RefCell<T>`        | `parking_lot::RwLock<T>`        |
-//! | `MTLock<T>`        [^1] | `T`                 | `Lock<T>`                       |
-//!
-//! [^1]: `MTLock` is similar to `Lock`, but the serial version avoids the cost
-//! of a `RefCell`. This is appropriate when interior mutability is not
-//! required.
 
 use std::collections::HashMap;
 use std::hash::{BuildHasher, Hash};
@@ -106,38 +101,6 @@ mod mode {
     }
 }
 
-// FIXME(parallel_compiler): Get rid of these aliases across the compiler.
-
-#[derive(Debug, Default)]
-pub struct MTLock<T>(Lock<T>);
-
-impl<T> MTLock<T> {
-    #[inline(always)]
-    pub fn new(inner: T) -> Self {
-        MTLock(Lock::new(inner))
-    }
-
-    #[inline(always)]
-    pub fn into_inner(self) -> T {
-        self.0.into_inner()
-    }
-
-    #[inline(always)]
-    pub fn get_mut(&mut self) -> &mut T {
-        self.0.get_mut()
-    }
-
-    #[inline(always)]
-    pub fn lock(&self) -> LockGuard<'_, T> {
-        self.0.lock()
-    }
-
-    #[inline(always)]
-    pub fn lock_mut(&self) -> LockGuard<'_, T> {
-        self.lock()
-    }
-}
-
 /// This makes locks panic if they are already held.
 /// It is only useful when you are running in a single thread
 const ERROR_CHECKING: bool = false;

compiler/rustc_hir_analysis/src/delegation.rs

@@ -339,10 +339,14 @@ fn create_generic_args<'tcx>(
         | (FnKind::AssocTrait, FnKind::AssocTrait) => delegation_args,
 
         (FnKind::AssocTraitImpl, FnKind::AssocTrait) => {
-            // Special case, as user specifies Trait args in impl trait header, we want to treat
-            // them as parent args.
+            // Special case, as user specifies Trait args in trait impl header, we want to treat
+            // them as parent args. We always generate a function whose generics match
+            // child generics in trait.
             let parent = tcx.local_parent(delegation_id);
             parent_args = tcx.impl_trait_header(parent).trait_ref.instantiate_identity().args;
+
+            assert!(child_args.is_empty(), "Child args can not be used in trait impl case");
+
             tcx.mk_args(&delegation_args[delegation_parent_args_count..])
         }
 

compiler/rustc_monomorphize/src/collector.rs

@@ -209,7 +209,7 @@ use std::cell::OnceCell;
 use std::ops::ControlFlow;
 
 use rustc_data_structures::fx::FxIndexMap;
-use rustc_data_structures::sync::{MTLock, par_for_each_in};
+use rustc_data_structures::sync::{Lock, par_for_each_in};
 use rustc_data_structures::unord::{UnordMap, UnordSet};
 use rustc_hir as hir;
 use rustc_hir::attrs::InlineAttr;
@@ -251,12 +251,12 @@ pub(crate) enum MonoItemCollectionStrategy {
 /// The state that is shared across the concurrent threads that are doing collection.
 struct SharedState<'tcx> {
     /// Items that have been or are currently being recursively collected.
-    visited: MTLock<UnordSet<MonoItem<'tcx>>>,
+    visited: Lock<UnordSet<MonoItem<'tcx>>>,
     /// Items that have been or are currently being recursively treated as "mentioned", i.e., their
     /// consts are evaluated but nothing is added to the collection.
-    mentioned: MTLock<UnordSet<MonoItem<'tcx>>>,
+    mentioned: Lock<UnordSet<MonoItem<'tcx>>>,
     /// Which items are being used where, for better errors.
-    usage_map: MTLock<UsageMap<'tcx>>,
+    usage_map: Lock<UsageMap<'tcx>>,
 }
 
 pub(crate) struct UsageMap<'tcx> {
@@ -359,7 +359,7 @@ fn collect_items_root<'tcx>(
     state: &SharedState<'tcx>,
     recursion_limit: Limit,
 ) {
-    if !state.visited.lock_mut().insert(starting_item.node) {
+    if !state.visited.lock().insert(starting_item.node) {
         // We've been here already, no need to search again.
         return;
     }
@@ -568,21 +568,21 @@ fn collect_items_rec<'tcx>(
     // This is part of the output of collection and hence only relevant for "used" items.
     // ("Mentioned" items are only considered internally during collection.)
     if mode == CollectionMode::UsedItems {
-        state.usage_map.lock_mut().record_used(starting_item.node, &used_items);
+        state.usage_map.lock().record_used(starting_item.node, &used_items);
     }
 
     {
         let mut visited = OnceCell::default();
         if mode == CollectionMode::UsedItems {
             used_items
                 .items
-                .retain(|k, _| visited.get_mut_or_init(|| state.visited.lock_mut()).insert(*k));
+                .retain(|k, _| visited.get_mut_or_init(|| state.visited.lock()).insert(*k));
         }
 
         let mut mentioned = OnceCell::default();
         mentioned_items.items.retain(|k, _| {
             !visited.get_or_init(|| state.visited.lock()).contains(k)
-                && mentioned.get_mut_or_init(|| state.mentioned.lock_mut()).insert(*k)
+                && mentioned.get_mut_or_init(|| state.mentioned.lock()).insert(*k)
         });
     }
     if mode == CollectionMode::MentionedItems {
@@ -1810,9 +1810,9 @@ pub(crate) fn collect_crate_mono_items<'tcx>(
     debug!("building mono item graph, beginning at roots");
 
     let state = SharedState {
-        visited: MTLock::new(UnordSet::default()),
-        mentioned: MTLock::new(UnordSet::default()),
-        usage_map: MTLock::new(UsageMap::new()),
+        visited: Lock::new(UnordSet::default()),
+        mentioned: Lock::new(UnordSet::default()),
+        usage_map: Lock::new(UsageMap::new()),
     };
     let recursion_limit = tcx.recursion_limit();
 

compiler/rustc_target/src/callconv/hexagon.rs

@@ -1,36 +1,76 @@
-use rustc_abi::TyAbiInterface;
+use rustc_abi::{HasDataLayout, TyAbiInterface};
 
-use crate::callconv::{ArgAbi, FnAbi};
+use crate::callconv::{ArgAbi, FnAbi, Reg, Uniform};
 
-fn classify_ret<Ty>(ret: &mut ArgAbi<'_, Ty>) {
-    if ret.layout.is_aggregate() && ret.layout.size.bits() > 64 {
-        ret.make_indirect();
-    } else {
+fn classify_ret<'a, Ty, C>(_cx: &C, ret: &mut ArgAbi<'a, Ty>)
+where
+    Ty: TyAbiInterface<'a, C> + Copy,
+    C: HasDataLayout,
+{
+    if !ret.layout.is_sized() {
+        return;
+    }
+
+    if !ret.layout.is_aggregate() {
         ret.extend_integer_width_to(32);
+        return;
+    }
+
+    // Per the Hexagon ABI:
+    // - Aggregates up to 32 bits are returned in R0
+    // - Aggregates 33-64 bits are returned in R1:R0
+    // - Aggregates > 64 bits are returned indirectly via hidden first argument
+    let size = ret.layout.size;
+    let bits = size.bits();
+    if bits <= 32 {
+        ret.cast_to(Uniform::new(Reg::i32(), size));
+    } else if bits <= 64 {
+        ret.cast_to(Uniform::new(Reg::i64(), size));
+    } else {
+        ret.make_indirect();
     }
 }
 
 fn classify_arg<'a, Ty, C>(cx: &C, arg: &mut ArgAbi<'a, Ty>)
 where
     Ty: TyAbiInterface<'a, C> + Copy,
+    C: HasDataLayout,
 {
+    if !arg.layout.is_sized() {
+        return;
+    }
     if arg.layout.pass_indirectly_in_non_rustic_abis(cx) {
         arg.make_indirect();
         return;
     }
-    if arg.layout.is_aggregate() && arg.layout.size.bits() > 64 {
-        arg.make_indirect();
-    } else {
+
+    if !arg.layout.is_aggregate() {
         arg.extend_integer_width_to(32);
+        return;
+    }
+
+    // Per the Hexagon ABI:
+    // - Aggregates up to 32 bits are passed in a single register
+    // - Aggregates 33-64 bits are passed in a register pair
+    // - Aggregates > 64 bits are passed on the stack
+    let size = arg.layout.size;
+    let bits = size.bits();
+    if bits <= 32 {
+        arg.cast_to(Uniform::new(Reg::i32(), size));
+    } else if bits <= 64 {
+        arg.cast_to(Uniform::new(Reg::i64(), size));
+    } else {
+        arg.pass_by_stack_offset(None);
     }
 }
 
 pub(crate) fn compute_abi_info<'a, Ty, C>(cx: &C, fn_abi: &mut FnAbi<'a, Ty>)
 where
     Ty: TyAbiInterface<'a, C> + Copy,
+    C: HasDataLayout,
 {
     if !fn_abi.ret.is_ignore() {
-        classify_ret(&mut fn_abi.ret);
+        classify_ret(cx, &mut fn_abi.ret);
     }
 
     for arg in fn_abi.args.iter_mut() {