[wip] rustdoc: variances

fmease · fmease · commit 48f25fb2f002 · 2024-03-13T02:06:41.000+01:00
diff --git a/src/librustdoc/clean/auto_trait.rs b/src/librustdoc/clean/auto_trait.rs
@@ -106,7 +106,7 @@ where
                     self.cx,
                     tcx.generics_of(item_def_id),
                     ty::GenericPredicates::default(),
-                    item_def_id,
+                    item_def_id, // FIXME: ofc its DefKind is not an impl confusing the variance compution
                 );
                 let params = raw_generics.params;
 
@@ -457,7 +457,7 @@ where
             self.cx,
             tcx.generics_of(item_def_id),
             tcx.explicit_predicates_of(item_def_id),
-            item_def_id,
+            item_def_id, // FIXME: ofc its DefKind is not an impl confusing the variance compution
         );
         let mut generic_params = raw_generics.params;
 
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
@@ -322,7 +322,7 @@ fn clean_where_predicate<'tcx>(
             let bound_params = wbp
                 .bound_generic_params
                 .iter()
-                .map(|param| clean_generic_param(cx, None, param))
+                .map(|param| clean_generic_param(cx, param, None, None))
                 .collect();
             WherePredicate::BoundPredicate {
                 ty: clean_ty(wbp.bounded_ty, cx),
@@ -503,11 +503,12 @@ fn projection_to_path_segment<'tcx>(
 
 fn clean_generic_param_def<'tcx>(
     def: &ty::GenericParamDef,
+    variance: Option<ty::Variance>,
     cx: &mut DocContext<'tcx>,
 ) -> GenericParamDef {
     let (name, kind) = match def.kind {
         ty::GenericParamDefKind::Lifetime => {
-            (def.name, LifetimeParam { outlives: ThinVec::new() }.into())
+            (def.name, LifetimeParam { variance, outlives: ThinVec::new() }.into())
         }
         ty::GenericParamDefKind::Type { has_default, synthetic, .. } => {
             let default = has_default.then(|| {
@@ -521,6 +522,7 @@ fn clean_generic_param_def<'tcx>(
             (
                 def.name,
                 TypeParam {
+                    variance,
                     bounds: ThinVec::new(), // These are filled in from the where-clause.
                     default,
                     synthetic,
@@ -556,8 +558,9 @@ fn clean_generic_param_def<'tcx>(
 
 fn clean_generic_param<'tcx>(
     cx: &mut DocContext<'tcx>,
-    generics: Option<&hir::Generics<'tcx>>,
     param: &hir::GenericParam<'tcx>,
+    variance: Option<ty::Variance>,
+    generics: Option<&hir::Generics<'tcx>>,
 ) -> GenericParamDef {
     let (name, kind) = match param.kind {
         hir::GenericParamKind::Lifetime { .. } => {
@@ -574,7 +577,7 @@ fn clean_generic_param<'tcx>(
             } else {
                 ThinVec::new()
             };
-            (param.name.ident().name, LifetimeParam { outlives }.into())
+            (param.name.ident().name, LifetimeParam { variance, outlives }.into())
         }
         hir::GenericParamKind::Type { ref default, synthetic } => {
             let bounds = if let Some(generics) = generics {
@@ -589,7 +592,13 @@ fn clean_generic_param<'tcx>(
             };
             (
                 param.name.ident().name,
-                TypeParam { bounds, default: default.map(|t| clean_ty(t, cx)), synthetic }.into(),
+                TypeParam {
+                    variance,
+                    bounds,
+                    default: default.map(|t| clean_ty(t, cx)),
+                    synthetic,
+                }
+                .into(),
             )
         }
         hir::GenericParamKind::Const { ty, default, is_host_effect } => (
@@ -627,14 +636,42 @@ fn is_elided_lifetime(param: &hir::GenericParam<'_>) -> bool {
 pub(crate) fn clean_generics<'tcx>(
     generics: &hir::Generics<'tcx>,
     cx: &mut DocContext<'tcx>,
-    _item_def_id: DefId,
+    item_def_id: DefId,
 ) -> Generics {
+    // FIXME(fmease): Instead of querying the defkind, we could instead let the caller make the decision
+    //                NOTE: This would also fix us rendering variances in synthetic impls which use the
+    //                DefId of the ADT.
+    // FIXME(fmease): Add DefKind::TyAlias if type_alias_is_lazy()
+    let def_kind = cx.tcx.def_kind(item_def_id);
+    let variances = if !generics.params.is_empty()
+        && let DefKind::Fn
+        | DefKind::AssocFn
+        | DefKind::Enum
+        | DefKind::Struct
+        | DefKind::Union
+        | DefKind::OpaqueTy = def_kind
+    {
+        let variances = cx.tcx.variances_of(item_def_id);
+        let generics = cx.tcx.generics_of(item_def_id);
+
+        eprintln!("::: item={item_def_id:?}  params={:?}", generics.params);
+        eprintln!("--> variances_raw={variances:?}");
+
+        Some((variances, generics))
+    } else {
+        None
+    };
+
     let impl_trait_params = generics
         .params
         .iter()
-        .filter(|param| is_impl_trait(param))
-        .map(|param| {
-            let param = clean_generic_param(cx, Some(generics), param);
+        .enumerate()
+        .filter(|(_, param)| is_impl_trait(param))
+        .map(|(_index, param)| {
+            // FIXME: this isn't correct for AssocFn since the variances also contain the parent variances, cut them off
+            // let variance = variances.map(|variances| variances[index]); // FIXME(fmease): impl
+            let variance = None;
+            let param = clean_generic_param(cx, param, variance, Some(generics));
             let GenericParamDefKind::Type(ty_param) = &param.kind else { unreachable!() };
             cx.impl_trait_bounds.insert(param.def_id.into(), ty_param.bounds.to_vec());
             param
@@ -692,7 +729,12 @@ pub(crate) fn clean_generics<'tcx>(
     // bounds in the where predicates. If so, we move their bounds into the where predicates
     // while also preventing duplicates.
     for param in generics.params.iter().filter(|p| !is_impl_trait(p) && !is_elided_lifetime(p)) {
-        let mut param = clean_generic_param(cx, Some(generics), param);
+        let variance = variances.and_then(|(variances, generics)| {
+            let index = generics.param_def_id_to_index.get(&param.def_id.to_def_id())?;
+            Some(variances[*index as usize])
+        });
+        let mut param = clean_generic_param(cx, param, variance, Some(generics));
+
         match &mut param.kind {
             GenericParamDefKind::Lifetime(lt_param) => {
                 if let Some(region_pred) = region_predicates.get_mut(&Lifetime(param.name)) {
@@ -746,8 +788,25 @@ fn clean_ty_generics<'tcx>(
     cx: &mut DocContext<'tcx>,
     generics: &ty::Generics,
     predicates: ty::GenericPredicates<'tcx>,
-    _item_def_id: DefId,
+    item_def_id: DefId,
 ) -> Generics {
+    // FIXME(fmease): Instead of querying the defkind, we could instead let the caller make the decision
+    //                NOTE: This would also fix us rendering variances in synthetic impls which use the
+    //                DefId of the ADT.
+    // FIXME(fmease): Add DefKind::TyAlias if type_alias_is_lazy()
+    let variances = if !generics.params.is_empty()
+        && let DefKind::Fn
+        | DefKind::AssocFn
+        | DefKind::Enum
+        | DefKind::Struct
+        | DefKind::Union
+        | DefKind::OpaqueTy = cx.tcx.def_kind(item_def_id)
+    {
+        Some(cx.tcx.variances_of(item_def_id))
+    } else {
+        None
+    };
+
     // Don't populate `cx.impl_trait_bounds` before `clean`ning `where` clauses,
     // since `Clean for ty::Predicate` would consume them.
     let mut impl_trait = BTreeMap::<ImplTraitParam, Vec<GenericBound>>::default();
@@ -758,22 +817,28 @@ fn clean_ty_generics<'tcx>(
     let stripped_params = generics
         .params
         .iter()
-        .filter_map(|param| match param.kind {
-            ty::GenericParamDefKind::Lifetime if param.is_anonymous_lifetime() => None,
-            ty::GenericParamDefKind::Lifetime => Some(clean_generic_param_def(param, cx)),
+        .filter(|param| match param.kind {
+            ty::GenericParamDefKind::Lifetime => !param.is_anonymous_lifetime(),
             ty::GenericParamDefKind::Type { synthetic, .. } => {
                 if param.name == kw::SelfUpper {
                     assert_eq!(param.index, 0);
-                    return None;
+                    return false;
                 }
                 if synthetic {
                     impl_trait.insert(param.index.into(), vec![]);
-                    return None;
+                    return false;
                 }
-                Some(clean_generic_param_def(param, cx))
+                true
             }
-            ty::GenericParamDefKind::Const { is_host_effect: true, .. } => None,
-            ty::GenericParamDefKind::Const { .. } => Some(clean_generic_param_def(param, cx)),
+            ty::GenericParamDefKind::Const { is_host_effect, .. } => !is_host_effect,
+        })
+        .map(|param| {
+            // FIXME(fmease): We will probably handle AssocFn incorrectly since it has
+            // parent generics (we prob need to offset shit)
+            let variance = variances
+                .map(|variances| variances[generics.param_def_id_to_index[&param.def_id] as usize]);
+
+            clean_generic_param_def(param, variance, cx)
         })
         .collect::<ThinVec<GenericParamDef>>();
 
@@ -1222,7 +1287,7 @@ fn clean_poly_trait_ref<'tcx>(
             .bound_generic_params
             .iter()
             .filter(|p| !is_elided_lifetime(p))
-            .map(|x| clean_generic_param(cx, None, x))
+            .map(|x| clean_generic_param(cx, x, None, None))
             .collect(),
     }
 }
@@ -2566,7 +2631,7 @@ fn clean_bare_fn_ty<'tcx>(
             .generic_params
             .iter()
             .filter(|p| !is_elided_lifetime(p))
-            .map(|x| clean_generic_param(cx, None, x))
+            .map(|x| clean_generic_param(cx, x, None, None)) // FIXME(fmease): variance?
             .collect();
         let args = clean_args_from_types_and_names(cx, bare_fn.decl.inputs, bare_fn.param_names);
         let decl = clean_fn_decl_with_args(cx, bare_fn.decl, None, args);
@@ -3152,8 +3217,14 @@ fn clean_bound_vars<'tcx>(
                 Some(GenericParamDef {
                     name,
                     def_id,
-                    kind: TypeParam { bounds: ThinVec::new(), default: None, synthetic: false }
-                        .into(),
+                    // FIXME(fmease): higher-ranked generic params don't have a variance, right?
+                    kind: TypeParam {
+                        variance: None,
+                        bounds: ThinVec::new(),
+                        default: None,
+                        synthetic: false,
+                    }
+                    .into(),
                 })
             }
             // FIXME(non_lifetime_binders): Support higher-ranked const parameters.
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
@@ -1356,11 +1356,13 @@ impl From<ConstParam> for GenericParamDefKind {
 
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub(crate) struct LifetimeParam {
+    pub(crate) variance: Option<ty::Variance>,
     pub(crate) outlives: ThinVec<Lifetime>,
 }
 
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub(crate) struct TypeParam {
+    pub(crate) variance: Option<ty::Variance>,
     pub(crate) bounds: ThinVec<GenericBound>,
     pub(crate) default: Option<Type>,
     pub(crate) synthetic: bool,
@@ -1382,7 +1384,9 @@ pub(crate) struct GenericParamDef {
 
 impl GenericParamDef {
     pub(crate) fn lifetime(def_id: DefId, name: Symbol) -> Self {
-        Self { name, def_id, kind: LifetimeParam { outlives: ThinVec::new() }.into() }
+        // FIXME(fmease): Don't use a fixed variance.
+        let param = LifetimeParam { variance: None, outlives: ThinVec::new() };
+        Self { name, def_id, kind: param.into() }
     }
 
     pub(crate) fn is_synthetic_param(&self) -> bool {
diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
@@ -189,7 +189,10 @@ impl clean::GenericParamDef {
     ) -> impl Display + 'a + Captures<'tcx> {
         display_fn(move |f| match &self.kind {
             clean::GenericParamDefKind::Lifetime(param) => {
-                write!(f, "{}", self.name)?;
+                if let Some(variance) = param.variance {
+                    f.write_str(print_variance(variance))?;
+                }
+                f.write_str(self.name.as_str())?;
 
                 if !param.outlives.is_empty() {
                     f.write_str(": ")?;
@@ -204,6 +207,9 @@ impl clean::GenericParamDef {
                 Ok(())
             }
             clean::GenericParamDefKind::Type(param) => {
+                if let Some(variance) = param.variance {
+                    f.write_str(print_variance(variance))?;
+                }
                 f.write_str(self.name.as_str())?;
 
                 if !param.bounds.is_empty() {
@@ -1749,6 +1755,17 @@ impl clean::Term {
     }
 }
 
+// FIXME(fmease): Do we need to care about alternate?
+fn print_variance(variance: ty::Variance) -> &'static str {
+    match variance {
+        // ty::Variance::Covariant => "",
+        ty::Variance::Covariant => "<sub class=\"variance\">+</sub>", // FIXME: temporary
+        ty::Variance::Invariant => r#"<sub class="variance" title="invariant">∘</sub>"#,
+        ty::Variance::Contravariant => r#"<sub class="variance" title="contravariant">−</sub>"#,
+        ty::Variance::Bivariant => r#"<sub class="variance" title="bivariant">∗</sub>"#,
+    }
+}
+
 pub(crate) fn display_fn(f: impl FnOnce(&mut fmt::Formatter<'_>) -> fmt::Result) -> impl Display {
     struct WithFormatter<F>(Cell<Option<F>>);
 
