[perf] only double-reverse default arguments

Author: fmease

src/librustdoc/clean/utils.rs

@@ -83,85 +83,132 @@ pub(crate) fn krate(cx: &mut DocContext<'_>) -> Crate {
 pub(crate) fn ty_args_to_args<'tcx>(
     cx: &mut DocContext<'tcx>,
     ty_args: ty::Binder<'tcx, &'tcx [ty::GenericArg<'tcx>]>,
-    skip_first: bool,
+    has_self: bool,
     container: Option<DefId>,
 ) -> Vec<GenericArg> {
+    let tcx = cx.tcx;
+    let bound_vars = ty_args.bound_vars();
+    let ty_args = ty_args.skip_binder();
+
+    let offset = if has_self { 1 } else { 0 };
+    let mut args = Vec::with_capacity(ty_args.len().saturating_sub(offset));
+
+    let params = container.map(|container| &tcx.generics_of(container).params);
+    let (req_args, opt_args) = if let Some(params) = params {
+        let partition_point = params
+            .iter()
+            .rposition(|param| match param.kind {
+                ty::GenericParamDefKind::Lifetime => false,
+                ty::GenericParamDefKind::Type { has_default, .. } => has_default,
+                ty::GenericParamDefKind::Const { has_default } => has_default,
+            })
+            // FIXME: using `offset` here might not be entirely correct
+            .unwrap_or(offset);
+        ty_args.split_at(partition_point)
+    } else {
+        (ty_args, &[] as _)
+    };
+
+    args.extend(req_args.iter().enumerate().filter_map(|(index, arg)| {
+        ty_arg_to_arg(cx, index, arg, has_self, container, ty_args, bound_vars)
+    }));
+
+    let skipped_self = args.len() != req_args.len();
     let param_env = ty::ParamEnv::empty();
     let cause = ObligationCause::dummy();
-    let params = container.map(|container| &cx.tcx.generics_of(container).params);
     let mut elision_has_failed_once_before = false;
 
-    let offset = if skip_first { 1 } else { 0 };
-    let mut args = Vec::with_capacity(ty_args.skip_binder().len().saturating_sub(offset));
-
-    let ty_arg_to_arg = |(index, arg): (usize, &ty::GenericArg<'tcx>)| match arg.unpack() {
-        GenericArgKind::Lifetime(lt) => {
-            Some(GenericArg::Lifetime(clean_middle_region(lt).unwrap_or(Lifetime::elided())))
-        }
-        GenericArgKind::Type(_) if skip_first && index == 0 => None,
-        GenericArgKind::Type(ty) => {
-            if !elision_has_failed_once_before
-                && let Some(params) = params
-                && let Some(default) = params[index].default_value(cx.tcx)
-            {
-                let default =
-                    ty_args.map_bound(|args| default.instantiate(cx.tcx, args).expect_ty());
-
-                if can_elide_generic_arg(
-                    cx.tcx,
-                    &cause,
-                    param_env,
-                    ty_args.rebind(ty),
-                    default,
-                    params[index].def_id,
-                ) {
-                    return None;
+    args.extend(
+        (req_args.len()..ty_args.len())
+            .zip(opt_args)
+            .rev()
+            .filter(|&(index, arg)| match arg.unpack() {
+                GenericArgKind::Lifetime(_) => true,
+                GenericArgKind::Type(ty) => {
+                    if !elision_has_failed_once_before
+                        && let Some(params) = params
+                        && let Some(default) = params[index].default_value(tcx)
+                    {
+                        let default = default.instantiate(tcx, ty_args).expect_ty();
+
+                        if can_elide_generic_arg(
+                            tcx,
+                            &cause,
+                            param_env,
+                            ty::Binder::bind_with_vars(ty, bound_vars),
+                            ty::Binder::bind_with_vars(default, bound_vars),
+                            params[index].def_id,
+                        ) {
+                            return false
+                        }
+
+                        elision_has_failed_once_before = true;
+                    }
+
+                    true
                 }
-
-                elision_has_failed_once_before = true;
-            }
-
-            Some(GenericArg::Type(clean_middle_ty(
-                ty_args.rebind(ty),
-                cx,
-                None,
-                container.map(|container| crate::clean::ContainerTy::Regular {
-                    ty: container,
-                    args: ty_args,
-                    arg: index,
-                }),
-            )))
-        }
-        GenericArgKind::Const(ct) => {
-            if !elision_has_failed_once_before
-                && let Some(params) = params
-                && let Some(default) = params[index].default_value(cx.tcx)
-            {
-                let default =
-                    ty_args.map_bound(|args| default.instantiate(cx.tcx, args).expect_const());
-
-                if can_elide_generic_arg(
-                    cx.tcx,
-                    &cause,
-                    param_env,
-                    ty_args.rebind(ct),
-                    default,
-                    params[index].def_id,
-                ) {
-                    return None;
+                GenericArgKind::Const(ct) => {
+                    if !elision_has_failed_once_before
+                        && let Some(params) = params
+                        && let Some(default) = params[index].default_value(tcx)
+                    {
+                        let default = default.instantiate(tcx, ty_args).expect_const();
+
+                        if can_elide_generic_arg(
+                            tcx,
+                            &cause,
+                            param_env,
+                            ty::Binder::bind_with_vars(ct, bound_vars),
+                            ty::Binder::bind_with_vars(default, bound_vars),
+                            params[index].def_id,
+                        ) {
+                            return false;
+                        }
+
+                        elision_has_failed_once_before = true;
+                    }
+
+                    true
                 }
+            })
+            .filter_map(|(index, arg)| {
+                ty_arg_to_arg(cx, index, arg, false, container, ty_args, bound_vars)
+            }),
+    );
+    args[req_args.len().saturating_sub(if skipped_self { 1 } else { 0 })..].reverse();
 
-                elision_has_failed_once_before = true;
-            }
+    args
+}
 
-            Some(GenericArg::Const(Box::new(clean_middle_const(ty_args.rebind(ct), cx))))
+fn ty_arg_to_arg<'tcx>(
+    cx: &mut DocContext<'tcx>,
+    index: usize,
+    arg: &ty::GenericArg<'tcx>,
+    has_self: bool,
+    container: Option<DefId>,
+    ty_args: &'tcx [ty::GenericArg<'tcx>],
+    bound_vars: &'tcx ty::List<ty::BoundVariableKind>,
+) -> Option<GenericArg> {
+    match arg.unpack() {
+        GenericArgKind::Lifetime(lt) => {
+            Some(GenericArg::Lifetime(clean_middle_region(lt).unwrap_or(Lifetime::elided())))
         }
-    };
-
-    // FIXME(fmease): This doesn't look performant to me!
-    args.extend(ty_args.skip_binder().iter().enumerate().rev().filter_map(ty_arg_to_arg));
-    args.reverse();
-    args
+        GenericArgKind::Type(_) if has_self && index == 0 => None,
+        GenericArgKind::Type(ty) => Some(GenericArg::Type(clean_middle_ty(
+            ty::Binder::bind_with_vars(ty, bound_vars),
+            cx,
+            None,
+            container.map(|container| crate::clean::ContainerTy::Regular {
+                ty: container,
+                args: ty::Binder::bind_with_vars(ty_args, bound_vars),
+                arg: index,
+            }),
+        ))),
+        GenericArgKind::Const(ct) => Some(GenericArg::Const(Box::new(clean_middle_const(
+            ty::Binder::bind_with_vars(ct, bound_vars),
+            cx,
+        )))),
+    }
 }
 
 fn can_elide_generic_arg<'tcx, T: ToTrace<'tcx> + TypeVisitable<TyCtxt<'tcx>>>(