WIP - doing experiments

Author: ShoyuVanilla

crates/hir-ty/src/db.rs

@@ -11,7 +11,7 @@ use base_db::{
 use hir_def::{
     db::DefDatabase, hir::ExprId, layout::TargetDataLayout, AdtId, BlockId, CallableDefId,
     ConstParamId, DefWithBodyId, EnumVariantId, FunctionId, GeneralConstId, GenericDefId, ImplId,
-    LifetimeParamId, LocalFieldId, StaticId, TypeAliasId, TypeOrConstParamId, VariantId,
+    LifetimeParamId, LocalFieldId, StaticId, TraitId, TypeAliasId, TypeOrConstParamId, VariantId,
 };
 use la_arena::ArenaMap;
 use smallvec::SmallVec;
@@ -24,6 +24,7 @@ use crate::{
     lower::{GenericDefaults, GenericPredicates},
     method_resolution::{InherentImpls, TraitImpls, TyFingerprint},
     mir::{BorrowckResult, MirBody, MirLowerError},
+    object_safety::{ObjectSafetyError, ObjectSafetyViolation},
     Binders, ClosureId, Const, FnDefId, ImplTraitId, ImplTraits, InferenceResult, Interner,
     PolyFnSig, Substitution, TraitEnvironment, TraitRef, Ty, TyDefId, ValueTyDefId,
 };
@@ -104,6 +105,12 @@ pub trait HirDatabase: DefDatabase + Upcast<dyn DefDatabase> {
     #[salsa::cycle(crate::layout::layout_of_ty_recover)]
     fn layout_of_ty(&self, ty: Ty, env: Arc<TraitEnvironment>) -> Result<Arc<Layout>, LayoutError>;
 
+    #[salsa::invoke(crate::object_safety::object_safety_of_trait_query)]
+    fn object_safety_of_trait(
+        &self,
+        trait_: TraitId,
+    ) -> Result<Option<ObjectSafetyViolation>, ObjectSafetyError>;
+
     #[salsa::invoke(crate::layout::target_data_layout_query)]
     fn target_data_layout(&self, krate: CrateId) -> Result<Arc<TargetDataLayout>, Arc<str>>;
 

crates/hir-ty/src/lib.rs

@@ -40,6 +40,7 @@ pub mod lang_items;
 pub mod layout;
 pub mod method_resolution;
 pub mod mir;
+pub mod object_safety;
 pub mod primitive;
 pub mod traits;
 

crates/hir-ty/src/object_safety.rs

@@ -0,0 +1,292 @@
+//! Compute the object-safety of a trait
+
+use std::ops::ControlFlow;
+
+use chalk_ir::{
+    visit::{TypeSuperVisitable, TypeVisitable, TypeVisitor},
+    BoundVar, DebruijnIndex, WhereClause,
+};
+use hir_def::{
+    lang_item::LangItem, AssocItemId, ConstId, FunctionId, GenericDefId, HasModule, TraitId,
+    TypeAliasId,
+};
+
+use crate::{
+    all_super_traits, db::HirDatabase, from_chalk_trait_id, generics::generics,
+    layout::LayoutError, lower::callable_item_sig, make_single_type_binders, static_lifetime,
+    utils::elaborate_clause_supertraits, wrap_empty_binders, AliasEq, AliasTy, Binders, DynTy,
+    Interner, QuantifiedWhereClauses, Substitution, TyBuilder, TyKind,
+};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ObjectSafetyError {
+    LayoutError(LayoutError),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ObjectSafetyViolation {
+    SizedSelf,
+    SelfReferential,
+    NonLifetimeBinder,
+    Method(FunctionId, MethodViolationCode),
+    AssocConst(ConstId),
+    GAT(TypeAliasId),
+    // This doesn't exist in rustc, but added for better visualization
+    HasNonSafeSuperTrait(TraitId),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum MethodViolationCode {
+    StaticMethod,
+    ReferencesSelfInput,
+    ReferencesSelfOutput,
+    ReferencesImplTraitInTrait,
+    AsyncFn,
+    WhereClauseReferencesSelf,
+    Generic,
+    UndispatchableReceiver,
+    HasNonLifetimeTypeParam,
+    NonReceiverSelfParam,
+}
+
+// Basically, this is almost same as `rustc_trait_selection::traits::object_safety`
+// but some difference;
+//
+// 1. While rustc gathers almost every violation, but this only early return on
+//    first violation for perf.
+//
+// These can be changed anytime while implementing.
+pub fn object_safety_of_trait_query(
+    db: &dyn HirDatabase,
+    trait_: TraitId,
+) -> Result<Option<ObjectSafetyViolation>, ObjectSafetyError> {
+    for super_trait in all_super_traits(db.upcast(), trait_).into_iter().skip(1) {
+        if db.object_safety_of_trait(super_trait)?.is_some() {
+            return Ok(Some(ObjectSafetyViolation::HasNonSafeSuperTrait(super_trait)));
+        }
+    }
+
+    // Check whether this has a `Sized` bound
+    if generics_require_sized_self(db, trait_.into()) {
+        return Ok(Some(ObjectSafetyViolation::SizedSelf));
+    }
+
+    if predicates_reference_self(db, trait_) {
+        return Ok(Some(ObjectSafetyViolation::SelfReferential));
+    }
+
+    // TODO: bound referencing self
+
+    // TODO: non lifetime binder
+
+    let trait_data = db.trait_data(trait_);
+    for (_, assoc_item) in &trait_data.items {
+        let item_violation = object_safety_violation_for_assoc_item(db, trait_, *assoc_item)?;
+        if item_violation.is_some() {
+            return Ok(item_violation);
+        }
+    }
+
+    Ok(None)
+}
+
+fn generics_require_sized_self(db: &dyn HirDatabase, def: GenericDefId) -> bool {
+    let krate = def.module(db.upcast()).krate();
+    let Some(sized) = db.lang_item(krate, LangItem::Sized).and_then(|l| l.as_trait()) else {
+        return false;
+    };
+
+    let predicates = &*db.generic_predicates(def);
+    let predicates = predicates.iter().map(|p| p.skip_binders().skip_binders().clone());
+    elaborate_clause_supertraits(db, predicates).any(|pred| match pred {
+        WhereClause::Implemented(trait_ref) => {
+            if from_chalk_trait_id(trait_ref.trait_id) == sized {
+                if let TyKind::BoundVar(it) =
+                    *trait_ref.self_type_parameter(Interner).kind(Interner)
+                {
+                    // Since `generic_predicates` is `Binder<Binder<..>>`, the `DebrujinIndex` of
+                    // self-parameter is `1`
+                    return it.index_if_bound_at(DebruijnIndex::new(1)).is_some_and(|i| i == 0);
+                }
+            }
+            false
+        }
+        _ => false,
+    })
+}
+
+fn predicates_reference_self(db: &dyn HirDatabase, trait_: TraitId) -> bool {
+    db.generic_predicates(trait_.into())
+        .iter()
+        .any(|pred| predicate_references_self(db, trait_, pred, AllowSelfProjection::No))
+}
+
+fn bounds_reference_self() {}
+
+#[derive(Clone, Copy)]
+enum AllowSelfProjection {
+    Yes,
+    No,
+}
+
+fn predicate_references_self(
+    db: &dyn HirDatabase,
+    trait_: TraitId,
+    predicate: &Binders<Binders<WhereClause<Interner>>>,
+    allow_self_projection: AllowSelfProjection,
+) -> bool {
+    match predicate.skip_binders().skip_binders() {
+        WhereClause::Implemented(trait_ref) => {
+            trait_ref.substitution.iter(Interner).skip(1).any(|arg| {
+                contains_illegal_self_type_reference(db, trait_, arg, allow_self_projection)
+            })
+        }
+        WhereClause::AliasEq(AliasEq { alias: AliasTy::Projection(proj), .. }) => {
+            proj.substitution.iter(Interner).skip(1).any(|arg| {
+                contains_illegal_self_type_reference(db, trait_, arg, allow_self_projection)
+            })
+        }
+        _ => false,
+    }
+}
+
+fn contains_illegal_self_type_reference<T: TypeVisitable<Interner>>(
+    db: &dyn HirDatabase,
+    trait_: TraitId,
+    t: &T,
+    allow_self_projection: AllowSelfProjection,
+) -> bool {
+    struct IllegalSelfTypeVisitor;
+    impl TypeVisitor<Interner> for IllegalSelfTypeVisitor {
+        type BreakTy = ();
+
+        fn as_dyn(&mut self) -> &mut dyn TypeVisitor<Interner, BreakTy = Self::BreakTy> {
+            self
+        }
+
+        fn interner(&self) -> Interner {
+            Interner
+        }
+
+        fn visit_ty(
+            &mut self,
+            ty: &chalk_ir::Ty<Interner>,
+            outer_binder: DebruijnIndex,
+        ) -> ControlFlow<Self::BreakTy> {
+            match ty.kind(Interner) {
+                TyKind::BoundVar(BoundVar { debruijn: DebruijnIndex::ONE, index: 0 }) => {
+                    ControlFlow::Break(())
+                }
+                // TODO: RPITIT -> Continue
+                TyKind::Alias(AliasTy::Projection(proj)) => {
+                    todo!()
+                }
+                _ => ty.super_visit_with(self.as_dyn(), outer_binder),
+            }
+        }
+
+        fn visit_const(
+            &mut self,
+            constant: &chalk_ir::Const<Interner>,
+            outer_binder: DebruijnIndex,
+        ) -> std::ops::ControlFlow<Self::BreakTy> {
+            constant.data(Interner).ty.super_visit_with(self.as_dyn(), outer_binder)
+        }
+    }
+
+    let mut visitor = IllegalSelfTypeVisitor;
+    t.visit_with(visitor.as_dyn(), DebruijnIndex::INNERMOST).is_break()
+}
+
+fn object_safety_violation_for_assoc_item(
+    db: &dyn HirDatabase,
+    trait_: TraitId,
+    item: AssocItemId,
+) -> Result<Option<ObjectSafetyViolation>, ObjectSafetyError> {
+    match item {
+        AssocItemId::ConstId(it) => Ok(Some(ObjectSafetyViolation::AssocConst(it))),
+        AssocItemId::FunctionId(it) => virtual_call_violations_for_method(db, trait_, it)
+            .map(|v| v.map(|v| ObjectSafetyViolation::Method(it, v)))
+            .map_err(ObjectSafetyError::LayoutError),
+        AssocItemId::TypeAliasId(it) => {
+            let generics = generics(db.upcast(), it.into());
+            // rustc checks if the `generic_associate_type_extended` feature gate is set
+            if generics.len_self() > 0 && db.type_alias_impl_traits(it).is_none() {
+                Ok(Some(ObjectSafetyViolation::GAT(it)))
+            } else {
+                Ok(None)
+            }
+        }
+    }
+}
+
+fn virtual_call_violations_for_method(
+    db: &dyn HirDatabase,
+    trait_: TraitId,
+    func: FunctionId,
+) -> Result<Option<MethodViolationCode>, LayoutError> {
+    let func_data = db.function_data(func);
+    if !func_data.has_self_param() {
+        return Ok(Some(MethodViolationCode::StaticMethod));
+    }
+
+    // TODO: check self reference in params
+
+    // TODO: check self reference in return type
+
+    // TODO: check asyncness, RPIT
+
+    let generic_params = db.generic_params(func.into());
+    if generic_params.len_type_or_consts() > 0 {
+        return Ok(Some(MethodViolationCode::Generic));
+    }
+
+    // Check if the receiver is a correct type like `Self`, `Box<Self>`, `Arc<Self>`, etc
+    //
+    // TODO: rustc does this in two steps :thinking_face:
+    //       I'm doing only the second, real one, layout check
+    // TODO: clean all the messes for building receiver types to check layout of
+
+    // Check for types like `Rc<()>`
+    let sig = callable_item_sig(db, func.into());
+    // TODO: Getting receiver type that substituted `Self` by `()`. there might be more clever way?
+    let subst = Substitution::from_iter(
+        Interner,
+        std::iter::repeat(TyBuilder::unit()).take(sig.len(Interner)),
+    );
+    let sig = sig.substitute(Interner, &subst);
+    let receiver_ty = sig.params()[0].to_owned();
+    let layout = db.layout_of_ty(receiver_ty, db.trait_environment(trait_.into()))?;
+
+    if !matches!(layout.abi, rustc_abi::Abi::Scalar(..)) {
+        return Ok(Some(MethodViolationCode::UndispatchableReceiver));
+    }
+
+    // Check for types like `Rc<dyn Trait>`
+    // TODO: `dyn Trait` and receiver type building is a total mess
+    let trait_ref =
+        TyBuilder::trait_ref(db, trait_).fill_with_bound_vars(DebruijnIndex::INNERMOST, 0).build();
+    let bound = wrap_empty_binders(WhereClause::Implemented(trait_ref));
+    let bounds = QuantifiedWhereClauses::from_iter(Interner, [bound]);
+    let dyn_trait = TyKind::Dyn(DynTy {
+        bounds: make_single_type_binders(bounds),
+        lifetime: static_lifetime(),
+    })
+    .intern(Interner);
+    let sig = callable_item_sig(db, func.into());
+    let subst = Substitution::from_iter(
+        Interner,
+        std::iter::once(dyn_trait)
+            .chain(std::iter::repeat(TyBuilder::unit()))
+            .take(sig.len(Interner)),
+    );
+    let sig = sig.substitute(Interner, &subst);
+    let receiver_ty = sig.params()[0].to_owned();
+    let layout = db.layout_of_ty(receiver_ty, db.trait_environment(trait_.into()))?;
+
+    if !matches!(layout.abi, rustc_abi::Abi::ScalarPair(..)) {
+        return Ok(Some(MethodViolationCode::UndispatchableReceiver));
+    }
+
+    Ok(None)
+}

crates/hir/src/lib.rs

@@ -66,7 +66,7 @@ use hir_ty::{
     diagnostics::BodyValidationDiagnostic,
     error_lifetime, known_const_to_ast,
     layout::{Layout as TyLayout, RustcEnumVariantIdx, RustcFieldIdx, TagEncoding},
-    method_resolution::{self},
+    method_resolution,
     mir::{interpret_mir, MutBorrowKind},
     primitive::UintTy,
     traits::FnTrait,
@@ -145,6 +145,7 @@ pub use {
         display::{ClosureStyle, HirDisplay, HirDisplayError, HirWrite},
         layout::LayoutError,
         mir::{MirEvalError, MirLowerError},
+        object_safety::{MethodViolationCode, ObjectSafetyError, ObjectSafetyViolation},
         FnAbi, PointerCast, Safety,
     },
     // FIXME: Properly encapsulate mir
@@ -2641,6 +2642,13 @@ impl Trait {
             .count()
     }
 
+    pub fn object_safety(
+        &self,
+        db: &dyn HirDatabase,
+    ) -> Result<Option<ObjectSafetyViolation>, ObjectSafetyError> {
+        db.object_safety_of_trait(self.id)
+    }
+
     fn all_macro_calls(&self, db: &dyn HirDatabase) -> Box<[(AstId<ast::Item>, MacroCallId)]> {
         db.trait_data(self.id)
             .macro_calls