Merge pull request #359 from yaahc/builtin

extend `TraitDefn` with concept of "well-known trait" identifier

Author: yaahc

chalk-integration/src/lowering.rs

@@ -1248,6 +1248,7 @@ impl LowerTrait for TraitDefn {
             binders: binders,
             flags: self.flags.lower(),
             associated_ty_ids,
+            well_known: self.well_known.map(|t| t.lower()),
         };
 
         debug!("trait_datum={:?}", trait_datum);
@@ -1353,6 +1354,18 @@ impl LowerQuantifiedGoal for Goal {
     }
 }
 
+trait LowerWellKnownTrait {
+    fn lower(&self) -> rust_ir::WellKnownTrait;
+}
+
+impl LowerWellKnownTrait for WellKnownTrait {
+    fn lower(&self) -> rust_ir::WellKnownTrait {
+        match self {
+            Self::SizedTrait => rust_ir::WellKnownTrait::SizedTrait,
+        }
+    }
+}
+
 /// Lowers LowerResult<Vec<T>> -> Vec<LowerResult<T>>.
 trait ApplyResult {
     type Output;

chalk-ir/src/lib.rs

@@ -144,6 +144,10 @@ impl UniverseIndex {
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct StructId<I: Interner>(pub I::DefId);
 
+/// The id of a trait definition; could be used to load the trait datum by
+/// invoking the [`trait_datum`] method.
+///
+/// [`trait_datum`]: ../chalk_solve/trait.RustIrDatabase.html#tymethod.trait_datum
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct TraitId<I: Interner>(pub I::DefId);
 
@@ -153,6 +157,10 @@ pub struct ImplId<I: Interner>(pub I::DefId);
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct ClauseId<I: Interner>(pub I::DefId);
 
+/// The id for the associated type member of a trait. The details of the type
+/// can be found by invoking the [`associated_ty_data`] method.
+///
+/// [`associated_ty_data`]: ../chalk_solve/trait.RustIrDatabase.html#tymethod.associated_ty_data
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct AssocTypeId<I: Interner>(pub I::DefId);
 

chalk-parse/src/ast.rs

@@ -48,6 +48,12 @@ pub struct TraitDefn {
     pub where_clauses: Vec<QuantifiedWhereClause>,
     pub assoc_ty_defns: Vec<AssocTyDefn>,
     pub flags: TraitFlags,
+    pub well_known: Option<WellKnownTrait>,
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub enum WellKnownTrait {
+    SizedTrait,
 }
 
 #[derive(Clone, PartialEq, Eq, Debug)]

chalk-parse/src/lib.rs

@@ -1,4 +1,5 @@
 #![recursion_limit = "1024"]
+#![allow(unused_parens)]
 
 #[macro_use]
 extern crate lalrpop_util;

chalk-parse/src/parser.lalrpop

@@ -43,6 +43,10 @@ FundamentalKeyword: () = "#" "[" "fundamental" "]";
 NonEnumerableKeyword: () = "#" "[" "non_enumerable" "]";
 CoinductiveKeyword: () = "#" "[" "coinductive" "]";
 
+WellKnownTrait: WellKnownTrait = {
+     "#" "[" "lang" "(" "sized" ")" "]" => WellKnownTrait::SizedTrait,
+};
+
 StructDefn: StructDefn = {
     <upstream:UpstreamKeyword?> <fundamental:FundamentalKeyword?> "struct" <n:Id><p:Angle<ParameterKind>>
         <w:QuantifiedWhereClauses> "{" <f:Fields> "}" => StructDefn
@@ -59,13 +63,14 @@ StructDefn: StructDefn = {
 };
 
 TraitDefn: TraitDefn = {
-    <auto:AutoKeyword?> <marker:MarkerKeyword?> <upstream:UpstreamKeyword?> <fundamental:FundamentalKeyword?> <non_enumerable:NonEnumerableKeyword?> <coinductive:CoinductiveKeyword?> "trait" <n:Id><p:Angle<ParameterKind>>
+    <auto:AutoKeyword?> <marker:MarkerKeyword?> <upstream:UpstreamKeyword?> <fundamental:FundamentalKeyword?> <non_enumerable:NonEnumerableKeyword?> <coinductive:CoinductiveKeyword?> <well_known:WellKnownTrait?> "trait" <n:Id><p:Angle<ParameterKind>>
         <w:QuantifiedWhereClauses> "{" <a:AssocTyDefn*> "}" => TraitDefn
     {
         name: n,
         parameter_kinds: p,
         where_clauses: w,
         assoc_ty_defns: a,
+        well_known,
         flags: TraitFlags {
             auto: auto.is_some(),
             marker: marker.is_some(),

chalk-rust-ir/src/lib.rs

@@ -87,6 +87,30 @@ pub struct StructFlags {
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+/// A rust intermediate representation (rust_ir) of a Trait Definition. For
+/// example, given the following rust code:
+///
+/// ```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> {
     pub id: TraitId<I>,
 
@@ -97,8 +121,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.
     pub associated_ty_ids: Vec<AssocTypeId<I>>,
+
+    /// If this is a well-known trait, which one? If `None`, this is a regular,
+    /// user-defined trait.
+    pub well_known: Option<WellKnownTrait>,
+}
+
+/// 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.
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub enum WellKnownTrait {
+    SizedTrait,
 }
 
 impl<I: Interner> TraitDatum<I> {
@@ -128,11 +162,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,
+
+    /// 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.
+    ///
+    /// 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

@@ -10,6 +10,7 @@ use chalk_ir::*;
 use rustc_hash::FxHashSet;
 
 pub mod builder;
+mod builtin_traits;
 mod env_elaborator;
 pub mod program_clauses;
 
@@ -236,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

@@ -0,0 +1,15 @@
+use super::builder::ClauseBuilder;
+use crate::Interner;
+use crate::{TraitRef, WellKnownTrait};
+
+/// For well known traits we have special hard-coded impls, either as an
+/// optimization or to enforce special rules for correctness.
+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 */ }
+    }
+}

chalk-solve/src/lib.rs

@@ -24,7 +24,7 @@ pub trait RustIrDatabase<I: Interner>: Debug {
     /// Returns the datum for the associated type with the given id.
     fn associated_ty_data(&self, ty: AssocTypeId<I>) -> Arc<AssociatedTyDatum<I>>;
 
-    /// Returns the datum for the impl with the given id.
+    /// Returns the datum for the definition with the given id.
     fn trait_datum(&self, trait_id: TraitId<I>) -> Arc<TraitDatum<I>>;
 
     /// Returns the datum for the impl with the given id.