Minor reformatting

Author: varkor

src/librustc/infer/canonical.rs

@@ -107,8 +107,7 @@ pub enum CanonicalTyVarKind {
     /// General type variable `?T` that can be unified with arbitrary types.
     General,
 
-    // TODO(const_generics): make the docs better
-    /// Const type variable
+    /// Const type variable `?C` that can be unified with const expressions.
     Const,
 
     /// Integral type variable `?I` (that can only be unified with integral types).
@@ -393,22 +392,24 @@ impl<'cx, 'gcx, 'tcx> InferCtxt<'cx, 'gcx, 'tcx> {
             let k1 = substitute_value(self.tcx, result_subst, k1);
             let r2 = substitute_value(self.tcx, result_subst, r2);
             match k1.unpack() {
-                UnpackedKind::Lifetime(r1) =>
+                UnpackedKind::Lifetime(r1) => {
                     Obligation::new(
                         cause.clone(),
                         param_env,
                         ty::Predicate::RegionOutlives(
                             ty::Binder::dummy(ty::OutlivesPredicate(r1, r2))),
-                    ),
-
-                UnpackedKind::Type(t1) =>
+                    )
+                }
+                UnpackedKind::Type(t1) => {
                     Obligation::new(
                         cause.clone(),
                         param_env,
                         ty::Predicate::TypeOutlives(
                             ty::Binder::dummy(ty::OutlivesPredicate(t1, r2))),
-                    ),
-                UnpackedKind::Const(_) => unimplemented!(), // TODO(const_generics): does it even make sense to specify that a const outlives something?
+                    )
+                }
+                // TODO(const_generics): does it even make sense to specify that a const outlives something?
+                UnpackedKind::Const(_) => unimplemented!(),
             }
         })) as Box<dyn Iterator<Item = _>>
     }

src/librustc/ty/relate.rs

@@ -476,7 +476,7 @@ pub fn super_relate_tys<'a, 'gcx, 'tcx, R>(relation: &mut R,
                 }
                 match x.val {
                     ConstValue::Unevaluated(def_id, substs) => {
-                        // TODO(const_generics): this case should be entirely removed.
+                        // TODO(const_generics)
                         // FIXME(eddyb) get the right param_env.
                         let param_env = ty::ParamEnv::empty();
                         match tcx.lift_to_global(&substs) {

src/librustc_typeck/check/closure.rs

@@ -110,8 +110,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                     span_bug!(expr.span, "closure has region param")
                 }
                 GenericParamDefKind::Type { .. } => {
-                    self.infcx
-                        .next_ty_var(TypeVariableOrigin::ClosureSynthetic(expr.span)).into()
+                    self.infcx.next_ty_var(TypeVariableOrigin::ClosureSynthetic(expr.span)).into()
                 }
                 GenericParamDefKind::Const { .. } => {
                     unimplemented!() // TODO(const_generics):

src/librustc_typeck/collect.rs

@@ -953,6 +953,7 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
             i += 1;
             Some(ty_param)
         }
+
         // TODO(const_generics): should this be split out to put const parameters after type parameters?
         GenericParamKind::Const { ref ty } => {
             if param.name.name() == keywords::SelfType.name() {
@@ -974,6 +975,7 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
             i += 1;
             Some(const_param)
         }
+
         _ => None,
     }));
 

src/librustc_typeck/impl_wf_check.rs

@@ -136,7 +136,8 @@ fn enforce_impl_params_are_constrained<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                 }
             }
             ty::GenericParamDefKind::Const { .. } => {
-                // TODO(const_generics): This is all right, but the collection of const params in input_parameters is wrong
+                // TODO(const_generics): This is all right, but the collection
+                // of const params in input_parameters is wrong
                 //let param_ct = ty::ParamConst::for_def(param);
                 //if !input_parameters.contains(&ctp::Parameter::from(param_ct)) {
                 //    report_unused_parameter(tcx,

src/librustdoc/clean/mod.rs

@@ -1251,6 +1251,10 @@ impl<'tcx> Clean<Lifetime> for ty::GenericParamDef<'tcx> {
 
 impl Clean<Constant> for hir::ConstArg {
     fn clean(&self, _cx: &DocContext) -> Constant {
+        // Constant {
+        //     type_: ty.clean(cx),
+        //     expr: print_const_expr(self.value.body),
+        // }
         unimplemented!() // TODO(const_generics)
     }
 }