Auto merge of #794 - HKalbasi:ptr-metadata, r=compiler-errors

Add support for `Pointee` trait

cc rust-lang/rust-analyzer#13992

Author: bors

chalk-integration/src/lowering.rs

@@ -1140,6 +1140,7 @@ impl Lower for WellKnownTrait {
             WellKnownTrait::Generator => rust_ir::WellKnownTrait::Generator,
             WellKnownTrait::DispatchFromDyn => rust_ir::WellKnownTrait::DispatchFromDyn,
             WellKnownTrait::Tuple => rust_ir::WellKnownTrait::Tuple,
+            WellKnownTrait::Pointee => rust_ir::WellKnownTrait::Pointee,
         }
     }
 }

chalk-parse/src/ast.rs

@@ -162,6 +162,7 @@ pub enum WellKnownTrait {
     Generator,
     DispatchFromDyn,
     Tuple,
+    Pointee,
 }
 
 #[derive(Clone, PartialEq, Eq, Debug)]

chalk-parse/src/parser.lalrpop

@@ -70,6 +70,7 @@ WellKnownTrait: WellKnownTrait = {
      "#" "[" "lang" "(" "generator" ")" "]" => WellKnownTrait::Generator,
      "#" "[" "lang" "(" "dispatch_from_dyn" ")" "]" => WellKnownTrait::DispatchFromDyn,
      "#" "[" "lang" "(" "tuple_trait" ")" "]" => WellKnownTrait::Tuple,
+     "#" "[" "lang" "(" "pointee_trait" ")" "]" => WellKnownTrait::Pointee,
 };
 
 AdtReprAttr: AdtReprAttr = {

chalk-solve/src/clauses/builtin_traits.rs

@@ -1,12 +1,15 @@
 use super::{builder::ClauseBuilder, generalize};
-use crate::{CanonicalVarKinds, Interner, RustIrDatabase, TraitRef, WellKnownTrait};
+use crate::{
+    rust_ir::AdtKind, CanonicalVarKinds, Interner, RustIrDatabase, TraitRef, WellKnownTrait,
+};
 use chalk_ir::{Floundered, Substitution, Ty};
 
 mod clone;
 mod copy;
 mod discriminant_kind;
 mod fn_family;
 mod generator;
+mod pointee;
 mod sized;
 mod tuple;
 mod unsize;
@@ -54,6 +57,9 @@ pub fn add_builtin_program_clauses<I: Interner>(
             WellKnownTrait::Tuple => {
                 tuple::add_tuple_program_clauses(db, builder, self_ty)?;
             }
+            WellKnownTrait::Pointee => {
+                pointee::add_pointee_program_clauses(db, builder, self_ty)?;
+            }
             // There are no builtin impls provided for the following traits:
             WellKnownTrait::Unpin
             | WellKnownTrait::Drop
@@ -83,6 +89,16 @@ pub fn add_builtin_assoc_program_clauses<I: Interner>(
                 Ok(())
             })
         }
+        WellKnownTrait::Pointee => {
+            // If `self_ty` contains bound vars, we want to universally quantify them.
+            // `Generalize` collects them for us.
+            let generalized = generalize::Generalize::apply(db.interner(), self_ty);
+
+            builder.push_binders(generalized, |builder, self_ty| {
+                pointee::add_pointee_program_clauses(db, builder, self_ty)?;
+                Ok(())
+            })
+        }
         WellKnownTrait::DiscriminantKind => {
             discriminant_kind::add_discriminant_clauses(db, builder, self_ty)
         }
@@ -97,6 +113,26 @@ pub fn add_builtin_assoc_program_clauses<I: Interner>(
     }
 }
 
+/// Returns type of the last field of the input struct, which is useful for `Sized` and related
+/// traits. Returns `None` if the input is not a struct or it has no fields.
+fn last_field_of_struct<I: Interner>(
+    db: &dyn RustIrDatabase<I>,
+    id: chalk_ir::AdtId<I>,
+    subst: &Substitution<I>,
+) -> Option<Ty<I>> {
+    let adt_datum = db.adt_datum(id);
+    let interner = db.interner();
+    if adt_datum.kind != AdtKind::Struct {
+        return None;
+    }
+    let last_field_ty = adt_datum
+        .binders
+        .map_ref(|b| b.variants.last()?.fields.last().cloned())
+        .filter_map(|x| x)?
+        .substitute(interner, subst);
+    Some(last_field_ty)
+}
+
 /// Given a trait ref `T0: Trait` and a list of types `U0..Un`, pushes a clause of the form
 /// `Implemented(T0: Trait) :- Implemented(U0: Trait) .. Implemented(Un: Trait)`
 pub fn needs_impl_for_tys<I: Interner>(

chalk-solve/src/clauses/builtin_traits/pointee.rs

@@ -0,0 +1,149 @@
+use crate::clauses::ClauseBuilder;
+use crate::rust_ir::WellKnownTrait;
+use crate::{Interner, RustIrDatabase, TraitRef};
+use chalk_ir::{
+    AliasTy, Floundered, Normalize, ProjectionTy, Substitution, Ty, TyKind, TyVariableKind,
+};
+
+use super::last_field_of_struct;
+
+fn push_clauses<I: Interner>(
+    db: &dyn RustIrDatabase<I>,
+    builder: &mut ClauseBuilder<'_, I>,
+    self_ty: Ty<I>,
+    metadata: Ty<I>,
+) {
+    let interner = db.interner();
+    let trait_id = db.well_known_trait_id(WellKnownTrait::Pointee).unwrap();
+    let substitution = Substitution::from1(interner, self_ty);
+    let trait_datum = db.trait_datum(trait_id);
+    assert_eq!(
+        trait_datum.associated_ty_ids.len(),
+        1,
+        "Pointee trait should have exactly one associated type, found {:?}",
+        trait_datum.associated_ty_ids
+    );
+    let metadata_id = trait_datum.associated_ty_ids[0];
+    let alias = AliasTy::Projection(ProjectionTy {
+        associated_ty_id: metadata_id,
+        substitution,
+    });
+    builder.push_fact(Normalize {
+        alias,
+        ty: metadata,
+    });
+}
+
+/// Add implicit impl for the `Pointee` trait for all types
+pub fn add_pointee_program_clauses<I: Interner>(
+    db: &dyn RustIrDatabase<I>,
+    builder: &mut ClauseBuilder<'_, I>,
+    self_ty: Ty<I>,
+) -> Result<(), Floundered> {
+    let interner = db.interner();
+    let trait_id = db.well_known_trait_id(WellKnownTrait::Pointee).unwrap();
+    let substitution = Substitution::from1(interner, self_ty.clone());
+    builder.push_fact(TraitRef {
+        trait_id,
+        substitution: substitution.clone(),
+    });
+    match self_ty.kind(interner) {
+        TyKind::Str | TyKind::Slice(_) => push_clauses(
+            db,
+            builder,
+            self_ty.clone(),
+            TyKind::Scalar(chalk_ir::Scalar::Uint(chalk_ir::UintTy::Usize)).intern(interner),
+        ),
+        TyKind::Array(_, _)
+        | TyKind::Never
+        | TyKind::Closure(_, _)
+        | TyKind::FnDef(_, _)
+        | TyKind::Scalar(_)
+        | TyKind::Raw(_, _)
+        | TyKind::Function(_)
+        | TyKind::InferenceVar(_, TyVariableKind::Float)
+        | TyKind::InferenceVar(_, TyVariableKind::Integer)
+        | TyKind::Generator(_, _)
+        | TyKind::GeneratorWitness(_, _)
+        | TyKind::Ref(_, _, _) => push_clauses(
+            db,
+            builder,
+            self_ty,
+            TyKind::Tuple(0, Substitution::empty(interner)).intern(interner),
+        ),
+        TyKind::Adt(id, subst) => {
+            if let Some(last_field_ty) = last_field_of_struct(db, *id, subst) {
+                push_for_last_field(last_field_ty, db, builder, self_ty);
+            } else {
+                push_clauses(
+                    db,
+                    builder,
+                    self_ty,
+                    TyKind::Tuple(0, Substitution::empty(interner)).intern(interner),
+                );
+            }
+        }
+        TyKind::Tuple(_, subst) => {
+            let last_field_ty = subst
+                .iter(interner)
+                .rev()
+                .next()
+                .and_then(|x| x.ty(interner))
+                .cloned();
+            if let Some(last_field_ty) = last_field_ty {
+                push_for_last_field(last_field_ty, db, builder, self_ty);
+            } else {
+                push_clauses(
+                    db,
+                    builder,
+                    self_ty,
+                    TyKind::Tuple(0, Substitution::empty(interner)).intern(interner),
+                );
+            }
+        }
+        TyKind::BoundVar(_)
+        | TyKind::AssociatedType(_, _)
+        | TyKind::OpaqueType(_, _)
+        | TyKind::Foreign(_)
+        | TyKind::Error
+        | TyKind::Placeholder(_)
+        | TyKind::Alias(_) => (),
+        TyKind::Dyn(_) => {
+            // FIXME: We should add a `Normalize(<dyn Trait as Pointee>::Metadata -> DynMetadata<dyn Trait>)` here, but
+            // since chalk doesn't have the concept of lang item structs yet, we can't.
+        }
+        TyKind::InferenceVar(_, TyVariableKind::General) => return Err(Floundered),
+    }
+    Ok(())
+}
+
+fn push_for_last_field<I: Interner>(
+    last_field_ty: Ty<I>,
+    db: &dyn RustIrDatabase<I>,
+    builder: &mut ClauseBuilder<'_, I>,
+    self_ty: Ty<I>,
+) {
+    let interner = db.interner();
+    let _ = add_pointee_program_clauses(db, builder, last_field_ty.clone());
+    let trait_id = db.well_known_trait_id(WellKnownTrait::Pointee).unwrap();
+    let trait_datum = db.trait_datum(trait_id);
+    assert_eq!(
+        trait_datum.associated_ty_ids.len(),
+        1,
+        "Pointee trait should have exactly one associated type, found {:?}",
+        trait_datum.associated_ty_ids
+    );
+    let metadata_id = trait_datum.associated_ty_ids[0];
+    let alias_last_field = AliasTy::Projection(ProjectionTy {
+        associated_ty_id: metadata_id,
+        substitution: Substitution::from1(interner, last_field_ty),
+    });
+    let alias_self = AliasTy::Projection(ProjectionTy {
+        associated_ty_id: metadata_id,
+        substitution: Substitution::from1(interner, self_ty),
+    });
+    builder.push_fact(Normalize {
+        alias: alias_self,
+        ty: TyKind::Alias(alias_last_field).intern(interner),
+    });
+}

chalk-solve/src/clauses/builtin_traits/sized.rs

@@ -2,39 +2,22 @@ use std::iter;
 
 use crate::clauses::builtin_traits::needs_impl_for_tys;
 use crate::clauses::ClauseBuilder;
-use crate::rust_ir::AdtKind;
 use crate::{Interner, RustIrDatabase, TraitRef};
 use chalk_ir::{
     AdtId, CanonicalVarKinds, Floundered, Substitution, TyKind, TyVariableKind, VariableKind,
 };
 
+use super::last_field_of_struct;
+
 fn push_adt_sized_conditions<I: Interner>(
     db: &dyn RustIrDatabase<I>,
     builder: &mut ClauseBuilder<'_, I>,
     trait_ref: TraitRef<I>,
     adt_id: AdtId<I>,
     substitution: &Substitution<I>,
 ) {
-    let adt_datum = db.adt_datum(adt_id);
-
-    // WF ensures that all enums are Sized, so we only have to consider structs.
-    if adt_datum.kind != AdtKind::Struct {
-        builder.push_fact(trait_ref);
-        return;
-    }
-
-    let interner = db.interner();
-
-    // To check if a struct S<..> is Sized, we only have to look at its last field.
-    // This is because the WF checks for ADTs require that all the other fields must be Sized.
-    let last_field_ty = adt_datum
-        .binders
-        .map_ref(|b| b.variants.clone())
-        .substitute(interner, substitution)
-        .into_iter()
-        .take(1) // We have a struct so we're guaranteed one variant
-        .flat_map(|mut v| v.fields.pop());
-
+    // We only need to check last field of the struct here. Rest of the fields and cases are handled in WF.
+    let last_field_ty = last_field_of_struct(db, adt_id, substitution).into_iter();
     needs_impl_for_tys(db, builder, trait_ref, last_field_ty);
 }
 

chalk-solve/src/display/items.rs

@@ -206,6 +206,7 @@ impl<I: Interner> RenderAsRust<I> for TraitDatum<I> {
                 WellKnownTrait::Generator => "generator",
                 WellKnownTrait::DispatchFromDyn => "dispatch_from_dyn",
                 WellKnownTrait::Tuple => "tuple_trait",
+                WellKnownTrait::Pointee => "pointee",
             };
             writeln!(f, "#[lang({})]", name)?;
         }

chalk-solve/src/rust_ir.rs

@@ -277,6 +277,7 @@ pub enum WellKnownTrait {
     Generator,
     DispatchFromDyn,
     Tuple,
+    Pointee,
 }
 
 chalk_ir::const_visit!(WellKnownTrait);

chalk-solve/src/wf.rs

@@ -436,6 +436,7 @@ where
             | WellKnownTrait::Sized
             | WellKnownTrait::DiscriminantKind
             | WellKnownTrait::Generator
+            | WellKnownTrait::Pointee
             | WellKnownTrait::Tuple => false,
         };
 

tests/test/mod.rs

@@ -427,6 +427,7 @@ mod never;
 mod numerics;
 mod object_safe;
 mod opaque_types;
+mod pointee;
 mod projection;
 mod refs;
 mod scalars;