Initial changes to rename proj type to term

This just changes the name of projection type to term, which highlights where
other changes to using a term should go.

Author: JulianKnodt

chalk-engine/src/slg.rs

@@ -306,15 +306,15 @@ impl<I: Interner> MayInvalidate<I> {
 
     fn aggregate_projection_tys(
         &mut self,
-        new: &ProjectionTy<I>,
-        current: &ProjectionTy<I>,
+        new: &ProjectionTerm<I>,
+        current: &ProjectionTerm<I>,
     ) -> bool {
-        let ProjectionTy {
-            associated_ty_id: new_name,
+        let ProjectionTerm {
+            associated_term_id: new_name,
             substitution: new_substitution,
         } = new;
-        let ProjectionTy {
-            associated_ty_id: current_name,
+        let ProjectionTerm {
+            associated_term_id: current_name,
             substitution: current_substitution,
         } = current;
 

chalk-engine/src/slg/aggregate.rs

@@ -382,23 +382,23 @@ impl<I: Interner> AntiUnifier<'_, I> {
 
     fn aggregate_projection_tys(
         &mut self,
-        proj1: &ProjectionTy<I>,
-        proj2: &ProjectionTy<I>,
+        proj1: &ProjectionTerm<I>,
+        proj2: &ProjectionTerm<I>,
     ) -> Ty<I> {
         let interner = self.interner;
-        let ProjectionTy {
-            associated_ty_id: name1,
+        let ProjectionTerm {
+            associated_term_id: name1,
             substitution: substitution1,
         } = proj1;
-        let ProjectionTy {
-            associated_ty_id: name2,
+        let ProjectionTerm {
+            associated_term_id: name2,
             substitution: substitution2,
         } = proj2;
 
         self.aggregate_name_and_substs(name1, substitution1, name2, substitution2)
-            .map(|(&associated_ty_id, substitution)| {
-                TyKind::Alias(AliasTy::Projection(ProjectionTy {
-                    associated_ty_id,
+            .map(|(&associated_term_id, substitution)| {
+                TyKind::Alias(AliasTy::Projection(ProjectionTerm {
+                    associated_term_id,
                     substitution,
                 }))
                 .intern(interner)

chalk-integration/src/db.rs

@@ -7,7 +7,7 @@ use crate::{
     tls, SolverChoice,
 };
 use chalk_ir::{
-    AdtId, AssocTypeId, Binders, Canonical, CanonicalVarKinds, ClosureId, ConstrainedSubst,
+    AdtId, AssocItemId, Binders, Canonical, CanonicalVarKinds, ClosureId, ConstrainedSubst,
     Environment, FnDefId, GeneratorId, GenericArg, Goal, ImplId, InEnvironment, OpaqueTyId,
     ProgramClause, ProgramClauses, Substitution, TraitId, Ty, TyKind, UCanonical,
     UnificationDatabase, Variances,
@@ -87,7 +87,7 @@ impl RustIrDatabase<ChalkIr> for ChalkDatabase {
         self.program_ir().unwrap().custom_clauses()
     }
 
-    fn associated_ty_data(&self, ty: AssocTypeId<ChalkIr>) -> Arc<AssociatedTyDatum<ChalkIr>> {
+    fn associated_ty_data(&self, ty: AssocItemId<ChalkIr>) -> Arc<AssociatedTyDatum<ChalkIr>> {
         self.program_ir().unwrap().associated_ty_data(ty)
     }
 
@@ -231,7 +231,7 @@ impl RustIrDatabase<ChalkIr> for ChalkDatabase {
         self.program_ir().unwrap().adt_name(struct_id)
     }
 
-    fn assoc_type_name(&self, assoc_ty_id: AssocTypeId<ChalkIr>) -> String {
+    fn assoc_type_name(&self, assoc_ty_id: AssocItemId<ChalkIr>) -> String {
         self.program_ir().unwrap().assoc_type_name(assoc_ty_id)
     }
 

chalk-integration/src/interner.rs

@@ -4,9 +4,9 @@ use chalk_ir::{
     TyKind,
 };
 use chalk_ir::{
-    AdtId, AliasTy, AssocTypeId, CanonicalVarKind, CanonicalVarKinds, ConstData, Constraint,
+    AdtId, AliasTy, AssocItemId, CanonicalVarKind, CanonicalVarKinds, ConstData, Constraint,
     Constraints, FnDefId, Goals, InEnvironment, Lifetime, OpaqueTy, OpaqueTyId,
-    ProgramClauseImplication, ProgramClauses, ProjectionTy, QuantifiedWhereClauses,
+    ProgramClauseImplication, ProgramClauses, ProjectionTerm, QuantifiedWhereClauses,
     SeparatorTraitRef, Substitution, TraitId, Ty, TyData, VariableKind, VariableKinds, Variances,
 };
 use chalk_ir::{
@@ -91,7 +91,7 @@ impl Interner for ChalkIr {
     }
 
     fn debug_assoc_type_id(
-        id: AssocTypeId<ChalkIr>,
+        id: AssocItemId<ChalkIr>,
         fmt: &mut fmt::Formatter<'_>,
     ) -> Option<fmt::Result> {
         tls::with_current_program(|prog| Some(prog?.debug_assoc_type_id(id, fmt)))
@@ -113,7 +113,7 @@ impl Interner for ChalkIr {
     }
 
     fn debug_projection_ty(
-        proj: &ProjectionTy<ChalkIr>,
+        proj: &ProjectionTerm<ChalkIr>,
         fmt: &mut fmt::Formatter<'_>,
     ) -> Option<fmt::Result> {
         tls::with_current_program(|prog| Some(prog?.debug_projection_ty(proj, fmt)))

chalk-integration/src/lowering.rs

@@ -610,11 +610,11 @@ impl Lower for TraitFlags {
     }
 }
 
-impl LowerWithEnv for ProjectionTy {
-    type Lowered = chalk_ir::ProjectionTy<ChalkIr>;
+impl LowerWithEnv for ProjectionTerm {
+    type Lowered = chalk_ir::ProjectionTerm<ChalkIr>;
 
     fn lower(&self, env: &Env) -> LowerResult<Self::Lowered> {
-        let ProjectionTy {
+        let ProjectionTerm {
             ref trait_ref,
             ref name,
             ref args,
@@ -650,8 +650,8 @@ impl LowerWithEnv for ProjectionTy {
 
         args.extend(trait_substitution.iter(interner).cloned());
 
-        Ok(chalk_ir::ProjectionTy {
-            associated_ty_id: lookup.id,
+        Ok(chalk_ir::ProjectionTerm {
+            associated_term_id: lookup.id,
             substitution: chalk_ir::Substitution::from_iter(interner, args),
         })
     }

chalk-integration/src/lowering/env.rs

@@ -71,7 +71,7 @@ pub struct Env<'k> {
 /// ```
 #[derive(Debug, PartialEq, Eq)]
 pub struct AssociatedTyLookup {
-    pub id: chalk_ir::AssocTypeId<ChalkIr>,
+    pub id: chalk_ir::AssocItemId<ChalkIr>,
     pub addl_variable_kinds: Vec<chalk_ir::VariableKind<ChalkIr>>,
 }
 

chalk-integration/src/lowering/program_lowerer.rs

@@ -1,6 +1,6 @@
 use chalk_ir::cast::Cast;
 use chalk_ir::{
-    self, AdtId, AssocTypeId, BoundVar, ClosureId, DebruijnIndex, FnDefId, ForeignDefId,
+    self, AdtId, AssocItemId, BoundVar, ClosureId, DebruijnIndex, FnDefId, ForeignDefId,
     GeneratorId, ImplId, OpaqueTyId, TraitId, TyVariableKind, VariableKinds,
 };
 use chalk_parse::ast::*;
@@ -64,7 +64,7 @@ impl ProgramLowerer {
                     for defn in &d.assoc_ty_defns {
                         let addl_variable_kinds = defn.all_parameters();
                         let lookup = AssociatedTyLookup {
-                            id: AssocTypeId(self.next_item_id()),
+                            id: AssocItemId(self.next_item_id()),
                             addl_variable_kinds: addl_variable_kinds.anonymize(),
                         };
                         self.associated_ty_lookups

chalk-integration/src/program.rs

@@ -3,9 +3,9 @@ use crate::{tls, Identifier, TypeKind};
 use chalk_ir::{could_match::CouldMatch, UnificationDatabase};
 use chalk_ir::{debug::Angle, Variance};
 use chalk_ir::{
-    debug::SeparatorTraitRef, AdtId, AliasTy, AssocTypeId, Binders, CanonicalVarKinds, ClosureId,
+    debug::SeparatorTraitRef, AdtId, AliasTy, AssocItemId, Binders, CanonicalVarKinds, ClosureId,
     FnDefId, ForeignDefId, GeneratorId, GenericArg, Goal, Goals, ImplId, IntTy, Lifetime, OpaqueTy,
-    OpaqueTyId, ProgramClause, ProgramClauseImplication, ProgramClauses, ProjectionTy, Scalar,
+    OpaqueTyId, ProgramClause, ProgramClauseImplication, ProgramClauses, ProjectionTerm, Scalar,
     Substitution, TraitId, Ty, TyKind, UintTy, Variances,
 };
 use chalk_solve::rust_ir::{
@@ -95,7 +95,7 @@ pub struct Program {
     pub well_known_traits: BTreeMap<WellKnownTrait, TraitId<ChalkIr>>,
 
     /// For each associated ty declaration `type Foo` found in a trait:
-    pub associated_ty_data: BTreeMap<AssocTypeId<ChalkIr>, Arc<AssociatedTyDatum<ChalkIr>>>,
+    pub associated_ty_data: BTreeMap<AssocItemId<ChalkIr>, Arc<AssociatedTyDatum<ChalkIr>>>,
 
     /// For each user-specified clause
     pub custom_clauses: Vec<ProgramClause<ChalkIr>>,
@@ -149,13 +149,13 @@ impl tls::DebugContext for Program {
 
     fn debug_assoc_type_id(
         &self,
-        assoc_type_id: AssocTypeId<ChalkIr>,
+        assoc_type_id: AssocItemId<ChalkIr>,
         fmt: &mut fmt::Formatter<'_>,
     ) -> Result<(), fmt::Error> {
         if let Some(d) = self.associated_ty_data.get(&assoc_type_id) {
             write!(fmt, "({:?}::{})", d.trait_id, d.name)
         } else {
-            fmt.debug_struct("InvalidAssocTypeId")
+            fmt.debug_struct("InvalidAssocItemId")
                 .field("index", &assoc_type_id.0)
                 .finish()
         }
@@ -202,7 +202,7 @@ impl tls::DebugContext for Program {
 
     fn debug_projection_ty(
         &self,
-        projection_ty: &ProjectionTy<ChalkIr>,
+        projection_ty: &ProjectionTerm<ChalkIr>,
         fmt: &mut fmt::Formatter<'_>,
     ) -> Result<(), fmt::Error> {
         let (associated_ty_data, trait_params, other_params) = self.split_projection(projection_ty);
@@ -384,7 +384,7 @@ impl RustIrDatabase<ChalkIr> for Program {
         self.custom_clauses.clone()
     }
 
-    fn associated_ty_data(&self, ty: AssocTypeId<ChalkIr>) -> Arc<AssociatedTyDatum<ChalkIr>> {
+    fn associated_ty_data(&self, ty: AssocItemId<ChalkIr>) -> Arc<AssociatedTyDatum<ChalkIr>> {
         self.associated_ty_data[&ty].clone()
     }
 
@@ -582,7 +582,7 @@ impl RustIrDatabase<ChalkIr> for Program {
     // normally acceptable, but causes the re-parse tests for the .chalk syntax
     // writer to fail. This is because they use the `Eq` implementation on
     // Program, which checks for name equality.
-    fn assoc_type_name(&self, assoc_type_id: AssocTypeId<ChalkIr>) -> String {
+    fn assoc_type_name(&self, assoc_type_id: AssocItemId<ChalkIr>) -> String {
         self.associated_ty_data
             .get(&assoc_type_id)
             .unwrap()

chalk-integration/src/tls.rs

@@ -1,8 +1,8 @@
 use crate::interner::ChalkIr;
 use chalk_ir::{
-    debug::SeparatorTraitRef, AdtId, AliasTy, AssocTypeId, CanonicalVarKinds, Constraints, FnDefId,
+    debug::SeparatorTraitRef, AdtId, AliasTy, AssocItemId, CanonicalVarKinds, Constraints, FnDefId,
     GenericArg, Goal, Goals, Lifetime, OpaqueTy, OpaqueTyId, ProgramClause,
-    ProgramClauseImplication, ProgramClauses, ProjectionTy, QuantifiedWhereClauses, Substitution,
+    ProgramClauseImplication, ProgramClauses, ProjectionTerm, QuantifiedWhereClauses, Substitution,
     TraitId, Ty, VariableKinds, Variances,
 };
 use std::cell::RefCell;
@@ -28,7 +28,7 @@ pub trait DebugContext {
 
     fn debug_assoc_type_id(
         &self,
-        id: AssocTypeId<ChalkIr>,
+        id: AssocItemId<ChalkIr>,
         fmt: &mut fmt::Formatter<'_>,
     ) -> Result<(), fmt::Error>;
 
@@ -58,7 +58,7 @@ pub trait DebugContext {
 
     fn debug_projection_ty(
         &self,
-        proj: &ProjectionTy<ChalkIr>,
+        proj: &ProjectionTerm<ChalkIr>,
         fmt: &mut fmt::Formatter<'_>,
     ) -> Result<(), fmt::Error>;
 

chalk-ir/src/debug.rs

@@ -16,10 +16,10 @@ impl<I: Interner> Debug for AdtId<I> {
     }
 }
 
-impl<I: Interner> Debug for AssocTypeId<I> {
+impl<I: Interner> Debug for AssocItemId<I> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
         I::debug_assoc_type_id(*self, fmt)
-            .unwrap_or_else(|| write!(fmt, "AssocTypeId({:?})", self.0))
+            .unwrap_or_else(|| write!(fmt, "AssocItemId({:?})", self.0))
     }
 }
 
@@ -136,10 +136,10 @@ impl<I: Interner> Debug for QuantifiedWhereClauses<I> {
     }
 }
 
-impl<I: Interner> Debug for ProjectionTy<I> {
+impl<I: Interner> Debug for ProjectionTerm<I> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
         I::debug_projection_ty(self, fmt).unwrap_or_else(|| {
-            unimplemented!("cannot format ProjectionTy without setting Program in tls")
+            unimplemented!("cannot format ProjectionTerm without setting Program in tls")
         })
     }
 }
@@ -680,30 +680,30 @@ impl<I: Interner> Debug for TypeOutlives<I> {
 
 /// Helper struct for showing debug output for projection types.
 pub struct ProjectionTyDebug<'a, I: Interner> {
-    projection_ty: &'a ProjectionTy<I>,
+    projection_term: &'a ProjectionTerm<I>,
     interner: I,
 }
 
 impl<'a, I: Interner> Debug for ProjectionTyDebug<'a, I> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
         let ProjectionTyDebug {
-            projection_ty,
+            projection_term,
             interner,
         } = self;
         write!(
             fmt,
             "({:?}){:?}",
-            projection_ty.associated_ty_id,
-            projection_ty.substitution.with_angle(*interner)
+            projection_term.associated_term_id,
+            projection_term.substitution.with_angle(*interner)
         )
     }
 }
 
-impl<I: Interner> ProjectionTy<I> {
+impl<I: Interner> ProjectionTerm<I> {
     /// Show debug output for the projection type.
     pub fn debug<'a>(&'a self, interner: I) -> ProjectionTyDebug<'a, I> {
         ProjectionTyDebug {
-            projection_ty: self,
+            projection_term: self,
             interner,
         }
     }