do more stuff

Author: yaahc

chalk-integration/src/lowering.rs

@@ -1241,7 +1241,7 @@ impl LowerTrait for TraitDefn {
             binders: binders,
             flags: self.flags.lower(),
             associated_ty_ids,
-            well_known: self.well_known.as_ref().map(|t| t.lower()),
+            well_known: self.well_known.map(|t| t.lower()),
         })
     }
 }

chalk-parse/src/ast.rs

@@ -51,7 +51,7 @@ pub struct TraitDefn {
     pub well_known: Option<WellKnownTrait>,
 }
 
-#[derive(Clone, PartialEq, Eq, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
 pub enum WellKnownTrait {
     SizedTrait,
 }

chalk-rust-ir/src/lib.rs

@@ -87,11 +87,35 @@ pub struct StructFlags {
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
-/// A rust intermediate representation (rust_ir) of a Trait Definition.
+/// A rust intermediate representation (rust_ir) of a Trait Definition. For
+/// example, given the following rust code:
 ///
-/// Not to be confused with a rust_ir for a Trait Implementation, which is
-/// represented with ??? JRL
+/// ```compile_fail
+/// use std::fmt::Debug;
+///
+/// trait Foo<T>
+/// where
+///     T: Debug,
+/// {
+///     type Bar<U>;
+/// }
+/// ```
+///
+/// This would represent the `trait Foo` declaration. Note that the details of
+/// the trait members (e.g., the associated type declaration (`type Bar<U>`) are
+/// not contained in this type, and are represented separately (e.g., in
+/// [`AssociatedTyDatum`]).
+///
+/// Not to be confused with the rust_ir for a Trait Implementation, which is
+/// represented by [`ImplDatum`]
+///
+/// [`ImplDatum`]: struct.ImplDatum.html
+/// [`AssociatedTyDatum`]: struct.AssociatedTyDatum.html
 pub struct TraitDatum<I: Interner> {
+    /// The id of this trait; could be used to load the trait datum by invoking
+    /// the [`trait_datum`] method.
+    ///
+    /// [`trait_datum`]: ../chalk_solve/trait.RustIrDatabase.html#tymethod.trait_datum
     pub id: TraitId<I>,
 
     pub binders: Binders<TraitDatumBound<I>>,
@@ -101,15 +125,18 @@ pub struct TraitDatum<I: Interner> {
     /// chalk we add annotations like `#[auto]`.
     pub flags: TraitFlags,
 
-    /// The id of each associated type defined in the trait.
+    /// The ids for the associated type members of the trait. The details of
+    /// each type can be found by invoking the [`associated_ty_data`] method.
+    ///
+    /// [`associated_ty_data`]: ../chalk_solve/trait.RustIrDatabase.html#tymethod.associated_ty_data
     pub associated_ty_ids: Vec<AssocTypeId<I>>,
 
-    /// A marker indicating if this trait definition represents one of the
-    /// various builtin traits (sized, copy, etc)
+    /// A list of the traits that are "well known" to chalk, which means that
+    /// the chalk-solve crate has special, hard-coded impls for them.
     pub well_known: Option<WellKnownTrait>,
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub enum WellKnownTrait {
     SizedTrait,
 }
@@ -141,18 +168,34 @@ pub struct TraitDatumBound<I: Interner> {
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct TraitFlags {
+    /// An "auto trait" is one that is "automatically implemented" for every
+    /// struct, so long as no explicit impl is given.
+    ///
+    /// Examples are `Send` and `Sync`.
     pub auto: bool,
+
     pub marker: bool,
+
     /// Indicate that a trait is defined upstream (in a dependency), used during
     /// coherence checking.
     pub upstream: bool,
-    /// The trait equivalent of a struct fundamental, currently (2020-03-25)
-    /// there are no known fundamental traits.
+
+    /// A fundamental trait is a trait where adding an impl for an existing type
+    /// is considered a breaking change. Examples of fundamental traits are the
+    /// closure traits like `Fn` and `FnMut`.
+    ///
+    /// As of this writing (2020-03-27), fundamental traits are declared by the
+    /// unstable `#[fundamental]` attribute in rustc, and hence cannot appear
+    /// outside of the standard library.
     pub fundamental: bool,
+
     /// Indicates that chalk cannot list all of the implementations of the given
-    /// trait, likely because it is a publicly exported trait in a library JRL
-    /// ???.
+    /// trait, likely because it is a publicly exported trait in a library.
+    ///
+    /// Currently (2020-03-27) rustc and rust-analyzer mark all traits as
+    /// non_enumerable, and in the future it may become the only option.
     pub non_enumerable: bool,
+
     pub coinductive: bool,
 }
 

chalk-solve/src/clauses.rs

@@ -237,7 +237,9 @@ fn program_clauses_that_could_match<I: Interner>(
                 }
             }
 
-            // TODO sized, unsize_trait, builtin impls?
+            if let Some(well_known) = trait_datum.well_known {
+                builtin_traits::add_builtin_program_clauses(well_known, trait_ref, builder);
+            }
         }
         DomainGoal::Holds(WhereClause::AliasEq(alias_predicate)) => {
             db.associated_ty_data(alias_predicate.alias.associated_ty_id)

chalk-solve/src/clauses/builtin_traits.rs

@@ -1 +1,16 @@
+use crate::{TraitRef, WellKnownTrait};
+use crate::Interner;
+use super::builder::ClauseBuilder;
+
+pub fn add_builtin_program_clauses<I: Interner>(
+    well_known: WellKnownTrait,
+    _trait_ref: &TraitRef<I>,
+    _builder: &mut ClauseBuilder<I>,
+) {
+    match well_known {
+        WellKnownTrait::SizedTrait => {
+            /* TODO */
+        }
+    }
+}