Rename some more instances of Projection to Alias

Author: detrumi

chalk-ir/src/lib.rs

@@ -216,7 +216,7 @@ impl<TF: TypeFamily> Ty<TF> {
         }
     }
 
-    pub fn is_projection(&self) -> bool {
+    pub fn is_alias(&self) -> bool {
         match self.data() {
             TyData::Alias(..) => true,
             _ => false,
@@ -742,7 +742,7 @@ pub type QuantifiedWhereClause<TF> = Binders<WhereClause<TF>>;
 impl<TF: TypeFamily> WhereClause<TF> {
     /// Turn a where clause into the WF version of it i.e.:
     /// * `Implemented(T: Trait)` maps to `WellFormed(T: Trait)`
-    /// * `ProjectionEq(<T as Trait>::Item = Foo)` maps to `WellFormed(<T as Trait>::Item = Foo)`
+    /// * `AliasEq(<T as Trait>::Item = Foo)` maps to `WellFormed(<T as Trait>::Item = Foo)`
     /// * any other clause maps to itself
     pub fn into_well_formed_goal(self) -> DomainGoal<TF> {
         match self {

chalk-ir/src/macros.rs

@@ -23,8 +23,8 @@ macro_rules! ty {
         }).intern()
     };
 
-    (projection (item $n:tt) $($arg:tt)*) => {
-        $crate::TyData::Projection(AliasTy {
+    (alias (item $n:tt) $($arg:tt)*) => {
+        $crate::TyData::Alias(AliasTy {
             associated_ty_id: AssocTypeId(RawId { index: $n }),
             substitution: $crate::Substitution::from(vec![$(arg!($arg)),*] as Vec<$crate::Parameter<_>>),
         }).intern()

chalk-parse/src/parser.lalrpop

@@ -253,7 +253,7 @@ InlineClause: Clause = {
 WhereClause: WhereClause = {
     <t:TraitRef<":">> => WhereClause::Implemented { trait_ref: t },
 
-    // `T: Foo<U = Bar>` -- projection equality
+    // `T: Foo<U = Bar>` -- alias equality
     <s:Ty> ":" <t:Id> "<" <a:(<Comma<Parameter>> ",")?> <name:Id> <a2:Angle<Parameter>>
         "=" <ty:Ty> ">" =>
     {

chalk-solve/src/clauses.rs

@@ -181,7 +181,7 @@ fn program_clauses_that_could_match<TF: TypeFamily>(
             // ```
             // dyn(exists<T> {
             //     forall<'a> { Implemented(T: Fn<'a>) },
-            //     forall<'a> { ProjectionEq(<T as Fn<'a>>::Output, ()) },
+            //     forall<'a> { AliasEq(<T as Fn<'a>>::Output, ()) },
             // })
             // ```
             //
@@ -196,7 +196,7 @@ fn program_clauses_that_could_match<TF: TypeFamily>(
             // and
             //
             // ```
-            // forall<'a> { ProjectionEq(<dyn Fn(&u8) as Fn<'a>>::Output, ()) },
+            // forall<'a> { AliasEq(<dyn Fn(&u8) as Fn<'a>>::Output, ()) },
             // ```
             //
             // FIXME. This is presently rather wasteful, in that we

chalk-solve/src/clauses/program_clauses.rs

@@ -510,18 +510,18 @@ impl<TF: TypeFamily> ToProgramClauses<TF> for AssociatedTyDatum<TF> {
     /// we generate the 'fallback' rule:
     ///
     /// ```notrust
-    /// -- Rule ProjectionEq-Placeholder
+    /// -- Rule AliasEq-Placeholder
     /// forall<Self, 'a, T> {
-    ///     ProjectionEq(<Self as Foo>::Assoc<'a, T> = (Foo::Assoc<'a, T>)<Self>).
+    ///     AliasEq(<Self as Foo>::Assoc<'a, T> = (Foo::Assoc<'a, T>)<Self>).
     /// }
     /// ```
     ///
     /// and
     ///
     /// ```notrust
-    /// -- Rule ProjectionEq-Normalize
+    /// -- Rule AliasEq-Normalize
     /// forall<Self, 'a, T, U> {
-    ///     ProjectionEq(<T as Foo>::Assoc<'a, T> = U) :-
+    ///     AliasEq(<T as Foo>::Assoc<'a, T> = U) :-
     ///         Normalize(<T as Foo>::Assoc -> U).
     /// }
     /// ```
@@ -530,14 +530,14 @@ impl<TF: TypeFamily> ToProgramClauses<TF> for AssociatedTyDatum<TF> {
     ///
     /// ```notrust
     /// forall<T> {
-    ///     T: Foo :- exists<U> { ProjectionEq(<T as Foo>::Assoc = U) }.
+    ///     T: Foo :- exists<U> { AliasEq(<T as Foo>::Assoc = U) }.
     /// }
     /// ```
     ///
     /// but this caused problems with the recursive solver. In
     /// particular, whenever normalization is possible, we cannot
     /// solve that projection uniquely, since we can now elaborate
-    /// `ProjectionEq` to fallback *or* normalize it. So instead we
+    /// `AliasEq` to fallback *or* normalize it. So instead we
     /// handle this kind of reasoning through the `FromEnv` predicate.
     ///
     /// We also generate rules specific to WF requirements and implied bounds:
@@ -594,7 +594,7 @@ impl<TF: TypeFamily> ToProgramClauses<TF> for AssociatedTyDatum<TF> {
             // and placeholder type.
             //
             //    forall<Self> {
-            //        ProjectionEq(<Self as Foo>::Assoc = (Foo::Assoc)<Self>).
+            //        AliasEq(<Self as Foo>::Assoc = (Foo::Assoc)<Self>).
             //    }
             builder.push_fact(alias_eq);
 

chalk-solve/src/infer/test.rs

@@ -131,7 +131,7 @@ fn projection_eq() {
         .unify(
             &environment0,
             &a,
-            &ty!(apply (item 0) (projection (item 1) (expr a))),
+            &ty!(apply (item 0) (alias (item 1) (expr a))),
         )
         .unwrap_err();
 }

chalk-solve/src/infer/unify.rs

@@ -215,7 +215,7 @@ impl<'t, TF: TypeFamily> Unifier<'t, TF> {
     /// type `ty` (which might also be a projection). Creates a goal like
     ///
     /// ```notrust
-    /// ProjectionEq(<T as Trait>::Item = U)
+    /// AliasEq(<T as Trait>::Item = U)
     /// ```
     fn unify_alias_ty(&mut self, alias: &AliasTy<TF>, ty: &Ty<TF>) -> Fallible<()> {
         Ok(self.goals.push(InEnvironment::new(