Rollup merge of #159899 - LorrensP-2158466:generic_args_terms, r=khyperia

 `GenericArgs::types` triage + possible fixes

cc [#t-types/call-for-participation > `args.types()` triage and fixes](https://rust-lang.zulipchat.com/#narrow/channel/618216-t-types.2Fcall-for-participation/topic/.60args.2Etypes.28.29.60.20triage.20and.20fixes/with/612733487)

Author: jhpratt

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -1850,7 +1850,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
 
                 assert_eq!(tcx.trait_impl_of_assoc(def_id), None);
                 self.prove_clauses(
-                    args.types().map(|ty| ty::ClauseKind::WellFormed(ty.into())),
+                    args.terms().map(|t| ty::ClauseKind::WellFormed(t.into())),
                     locations,
                     ConstraintCategory::Boring,
                 );

compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs

@@ -1432,6 +1432,7 @@ fn build_generic_type_param_di_nodes<'ll, 'tcx>(
     ty: Ty<'tcx>,
 ) -> SmallVec<Option<&'ll DIType>> {
     if let ty::Adt(def, args) = *ty.kind() {
+        // FIXME: also do consts?
         if args.types().next().is_some() {
             let generics = cx.tcx.generics_of(def.did());
             let names = get_parameter_names(cx, generics);

compiler/rustc_codegen_llvm/src/debuginfo/mod.rs

@@ -289,7 +289,7 @@ impl<'ll, 'tcx> DebugInfoBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
             generics: &ty::Generics,
             args: GenericArgsRef<'tcx>,
         ) -> &'ll DIArray {
-            if args.types().next().is_none() {
+            if args.terms().next().is_none() {
                 return create_DIArray(DIB(cx), &[]);
             }
 
@@ -298,6 +298,7 @@ impl<'ll, 'tcx> DebugInfoBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                 let names = get_parameter_names(cx, generics);
                 iter::zip(args, names)
                     .filter_map(|(kind, name)| {
+                        // FIXME: debug info for consts (using `createTemplateValueParameter`?)
                         kind.as_type().map(|ty| {
                             let actual_type = cx.tcx.normalize_erasing_regions(
                                 cx.typing_env(),

compiler/rustc_middle/src/ty/generic_args.rs

@@ -518,6 +518,11 @@ impl<'tcx> GenericArgs<'tcx> {
         self.iter().filter_map(|k| k.as_const())
     }
 
+    #[inline]
+    pub fn terms(&self) -> impl DoubleEndedIterator<Item = ty::Term<'tcx>> {
+        self.iter().filter_map(|k| k.as_term())
+    }
+
     /// Returns generic arguments that are not lifetimes.
     #[inline]
     pub fn non_erasable_generics(&self) -> impl DoubleEndedIterator<Item = GenericArgKind<'tcx>> {

compiler/rustc_middle/src/ty/print/pretty.rs

@@ -2305,9 +2305,7 @@ impl<'tcx> Printer<'tcx> for FmtPrinter<'_, 'tcx> {
                         // `Foo<...>`.
                         if let Some(arg) = args.types().next() {
                             if let ty::Adt(_, arg_args) = arg.kind() {
-                                if arg_args.consts().next().is_none()
-                                    && arg_args.types().next().is_none()
-                                {
+                                if arg_args.terms().next().is_none() {
                                     // Single param type with no type or const parameters:
                                     // `Foo<Bar<'a>>`.
                                     true

compiler/rustc_mir_transform/src/function_item_references.rs

@@ -164,9 +164,7 @@ impl<'tcx> FunctionItemRefChecker<'_, 'tcx> {
             other_abi => format!("extern {other_abi} "),
         };
         let ident = self.tcx.item_ident(fn_id);
-        let ty_params = fn_args.types().map(|ty| format!("{ty}"));
-        let const_params = fn_args.consts().map(|c| format!("{c}"));
-        let params = ty_params.chain(const_params).join(", ");
+        let params = fn_args.terms().map(|term| format!("{term}")).join(", ");
         let num_args = fn_sig.inputs().map_bound(|inputs| inputs.len()).skip_binder();
         let variadic = if fn_sig.c_variadic() { ", ..." } else { "" };
         let ret = if fn_sig.output().skip_binder().is_unit() { "" } else { " -> _" };

compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs

@@ -678,7 +678,7 @@ impl<'tcx> InferSourceKind<'tcx> {
                     || matches!(
                         ty.kind(),
                         ty::Adt(_, args)
-                        if args.types().count() == 0 && args.consts().count() == 0
+                        if args.terms().next().is_none()
                     )
                 {
                     // `ty` is either `_`, a primitive type like `u32` or a type with no type or

compiler/rustc_trait_selection/src/error_reporting/traits/ambiguity.rs

@@ -182,17 +182,13 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
     /// share an inference variable into a single diagnostic.
     pub(super) fn ambiguity_term(&self, predicate: ty::Predicate<'tcx>) -> Option<ty::Term<'tcx>> {
         match predicate.kind().skip_binder() {
-            ty::PredicateKind::Clause(ty::ClauseKind::Trait(data)) => data
-                .trait_ref
-                .args
-                .iter()
-                .filter_map(ty::GenericArg::as_term)
-                .find(|term| term.has_non_region_infer()),
+            ty::PredicateKind::Clause(ty::ClauseKind::Trait(data)) => {
+                data.trait_ref.args.terms().find(|term| term.has_non_region_infer())
+            }
             ty::PredicateKind::Clause(ty::ClauseKind::Projection(data)) => data
                 .projection_term
                 .args
-                .iter()
-                .filter_map(ty::GenericArg::as_term)
+                .terms()
                 .chain([data.term])
                 .find(|term| term.has_non_region_infer()),
             ty::PredicateKind::Clause(ty::ClauseKind::WellFormed(term)) => Some(term),

compiler/rustc_trait_selection/src/traits/auto_trait.rs

@@ -454,7 +454,7 @@ impl<'tcx> AutoTraitFinder<'tcx> {
                     let new_args = new_trait.trait_ref.args;
                     let old_args = old_trait.trait_ref.args;
 
-                    if !new_args.types().eq(old_args.types()) {
+                    if !new_args.terms().eq(old_args.terms()) {
                         // We can't compare lifetimes if the types are different,
                         // so skip checking `old_clause`.
                         return true;
@@ -624,7 +624,7 @@ impl<'tcx> AutoTraitFinder<'tcx> {
     }
 
     fn is_param_no_infer(&self, args: GenericArgsRef<'tcx>) -> bool {
-        self.is_of_param(args.type_at(0)) && !args.types().any(|t| t.has_infer_types())
+        self.is_of_param(args.type_at(0)) && !args.terms().any(|t| t.has_infer_types())
     }
 
     pub fn is_of_param(&self, ty: Ty<'tcx>) -> bool {

compiler/rustc_trait_selection/src/traits/select/mod.rs

@@ -1217,6 +1217,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         // This suffices to allow chains like `FnMut` implemented in
         // terms of `Fn` etc, but we could probably make this more
         // precise still.
+        //
+        // FIXME(min_generic_const_args): Consider consts as well?
         let unbound_input_types =
             stack.fresh_trait_pred.skip_binder().trait_ref.args.types().any(|ty| ty.is_fresh());