address nits

Author: basil-cow

chalk-solve/src/clauses/builtin_traits.rs

@@ -1,8 +1,8 @@
-use std::iter;
-
 use super::builder::ClauseBuilder;
 use crate::{Interner, RustIrDatabase, TraitRef, WellKnownTrait};
-use chalk_ir::{ApplicationTy, Substitution, TyData, TypeName};
+use chalk_ir::TyData;
+
+mod sized;
 
 /// For well known traits we have special hard-coded impls, either as an
 /// optimization or to enforce special rules for correctness.
@@ -18,44 +18,8 @@ pub fn add_builtin_program_clauses<I: Interner>(
     }
 
     match well_known {
-        WellKnownTrait::SizedTrait => add_sized_program_clauses(db, builder, trait_ref, ty),
+        WellKnownTrait::SizedTrait => sized::add_sized_program_clauses(db, builder, trait_ref, ty),
         WellKnownTrait::CopyTrait => { /* TODO */ }
         WellKnownTrait::CloneTrait => { /* TODO */ }
     }
 }
-
-fn add_sized_program_clauses<I: Interner>(
-    db: &dyn RustIrDatabase<I>,
-    builder: &mut ClauseBuilder<'_, I>,
-    trait_ref: &TraitRef<I>,
-    ty: &TyData<I>,
-) {
-    let interner = db.interner();
-
-    let (struct_id, substitution) = match ty {
-        TyData::Apply(ApplicationTy {
-            name: TypeName::Struct(struct_id),
-            substitution,
-        }) => (*struct_id, substitution),
-        _ => return,
-    };
-
-    let struct_datum = db.struct_datum(struct_id);
-
-    if struct_datum.binders.map_ref(|b| b.fields.is_empty()).value {
-        builder.push_fact(trait_ref.clone());
-        return;
-    }
-
-    let last_field_ty = struct_datum
-        .binders
-        .map_ref(|b| b.fields.last().unwrap())
-        .substitute(interner, substitution)
-        .clone();
-
-    let last_field_sized_goal = TraitRef {
-        trait_id: trait_ref.trait_id,
-        substitution: Substitution::from1(interner, last_field_ty),
-    };
-    builder.push_clause(trait_ref.clone(), iter::once(last_field_sized_goal));
-}

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

@@ -0,0 +1,44 @@
+use std::iter;
+
+use crate::clauses::ClauseBuilder;
+use crate::{Interner, RustIrDatabase, TraitRef};
+use chalk_ir::{ApplicationTy, Substitution, TyData, TypeName};
+
+pub fn add_sized_program_clauses<I: Interner>(
+    db: &dyn RustIrDatabase<I>,
+    builder: &mut ClauseBuilder<'_, I>,
+    trait_ref: &TraitRef<I>,
+    ty: &TyData<I>,
+) {
+    let interner = db.interner();
+
+    let (struct_id, substitution) = match ty {
+        TyData::Apply(ApplicationTy {
+            name: TypeName::Struct(struct_id),
+            substitution,
+        }) => (*struct_id, substitution),
+        _ => return,
+    };
+
+    let struct_datum = db.struct_datum(struct_id);
+
+    // Structs with no fields are always Sized
+    if struct_datum.binders.map_ref(|b| b.fields.is_empty()).value {
+        builder.push_fact(trait_ref.clone());
+        return;
+    }
+
+    // To check if a struct type S<..> is Sized, we only have to look at its last field.
+    // This is because the WF checks for structs require that all the other fields must be Sized.
+    let last_field_ty = struct_datum
+        .binders
+        .map_ref(|b| b.fields.last().unwrap())
+        .substitute(interner, substitution)
+        .clone();
+
+    let last_field_sized_goal = TraitRef {
+        trait_id: trait_ref.trait_id,
+        substitution: Substitution::from1(interner, last_field_ty),
+    };
+    builder.push_clause(trait_ref.clone(), iter::once(last_field_sized_goal));
+}

chalk-solve/src/wf.rs

@@ -190,6 +190,7 @@ where
         let wg_goal = gb.forall(&struct_data, (), |gb, _, (fields, where_clauses), ()| {
             let interner = gb.interner();
 
+            // struct is well-formed in terms of Sized
             let sized_constraint_goal = compute_struct_sized_constraint(gb.db(), fields);
 
             // (FromEnv(T: Eq) => ...)
@@ -479,6 +480,9 @@ fn compute_assoc_ty_goal<I: Interner>(
     ))
 }
 
+/// Computes a goal to prove Sized constraints on a struct definition.
+/// Struct is considered well-formed (in terms of Sized) when it either
+/// has no fields or all of it's fields except the last are proven to be Sized.  
 fn compute_struct_sized_constraint<I: Interner>(
     db: &dyn RustIrDatabase<I>,
     fields: &[Ty<I>],