Naming and comment changes

Author: detrumi

chalk-integration/src/lowering.rs

@@ -1037,11 +1037,11 @@ impl LowerTy for Ty {
                         .map(|id| chalk_ir::ParameterKind::Lifetime(id.str)),
                 )?;
 
-                let quantified_ty = chalk_ir::Fn {
+                let function = chalk_ir::Fn {
                     num_binders: lifetime_names.len(),
                     parameters: vec![ty.lower(&quantified_env)?.cast()],
                 };
-                Ok(chalk_ir::TyData::Function(quantified_ty).intern())
+                Ok(chalk_ir::TyData::Function(function).intern())
             }
         }
     }

chalk-ir/src/debug.rs

@@ -63,7 +63,7 @@ impl<TF: TypeFamily> Debug for TyData<TF> {
             TyData::Apply(apply) => write!(fmt, "{:?}", apply),
             TyData::Projection(proj) => write!(fmt, "{:?}", proj),
             TyData::Placeholder(index) => write!(fmt, "{:?}", index),
-            TyData::Function(quantified_ty) => write!(fmt, "{:?}", quantified_ty),
+            TyData::Function(function) => write!(fmt, "{:?}", function),
         }
     }
 }

chalk-ir/src/fold.rs

@@ -324,9 +324,7 @@ where
         TyData::Projection(proj) => {
             Ok(TyData::Projection(proj.fold_with(folder, binders)?).intern())
         }
-        TyData::Function(quantified_ty) => {
-            Ok(TyData::Function(quantified_ty.fold_with(folder, binders)?).intern())
-        }
+        TyData::Function(fun) => Ok(TyData::Function(fun.fold_with(folder, binders)?).intern()),
     }
 }
 

chalk-ir/src/lib.rs

@@ -260,13 +260,10 @@ pub enum TyData<TF: TypeFamily> {
     /// trait and all its parameters are fully known.
     Projection(ProjectionTy<TF>),
 
-    /// A "higher-ranked" type. In the Rust surface syntax, this can
-    /// only be a function type (e.g., `for<'a> fn(&'a u32)`) or a dyn
-    /// type (e.g., `dyn for<'a> SomeTrait<&'a u32>`). However, in
-    /// Chalk's representation, we separate out the `for<'a>` part
-    /// from the underlying type, so technically we can represent
-    /// things like `for<'a> SomeStruct<'a>`, although that has no
-    /// meaning in Rust.
+    /// A function type such as `for<'a> fn(&'a u32)`.
+    /// Note that "higher-ranked" types (starting with `for<>`) are either
+    /// function types or dyn types, and do not appear otherwise in Rust
+    /// surface syntax.
     Function(Fn<TF>),
 
     /// References the binding at the given depth. The index is a [de

chalk-solve/src/infer/unify.rs

@@ -118,8 +118,8 @@ impl<'t, TF: TypeFamily> Unifier<'t, TF> {
             | (&TyData::Function(_), &TyData::InferenceVar(var)) => self.unify_var_ty(var, a),
 
             // Unifying `forall<X> { T }` with some other forall type `forall<X> { U }`
-            (&TyData::Function(ref quantified_ty1), &TyData::Function(ref quantified_ty2)) => {
-                self.unify_binders(quantified_ty1, quantified_ty2)
+            (&TyData::Function(ref fn1), &TyData::Function(ref fn2)) => {
+                self.unify_binders(fn1, fn2)
             }
 
             // This would correspond to unifying a `fn` type with a non-fn