Clean up unfinished parts

Author: varkor

src/librustc/infer/combine.rs

@@ -146,10 +146,7 @@ impl<'infcx, 'gcx, 'tcx> InferCtxt<'infcx, 'gcx, 'tcx> {
             // All other cases of inference with other variables are errors.
             (ConstValue::Infer(InferConst::Var(_)), ConstValue::Infer(_)) |
             (ConstValue::Infer(_), ConstValue::Infer(InferConst::Var(_))) => {
-                unimplemented!()
-                // TODO(const_generics): relate
-                // Err(TypeError::ConstError(
-                    // ConstError::Mismatch(ty::relate::expected_found(relation, &a, &b))))
+                bug!("tried to combine ConstValue::Infer/ConstValue::Infer(InferConst::Var)")
             }
 
 

src/librustc/infer/mod.rs

@@ -914,7 +914,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
     }
 
     pub fn next_const_var_id(&self, _origin: ConstVariableOrigin) -> ConstVid<'tcx> {
-        // TODO(const_generics): integrate _origin
+        // TODO(const_generics): integrate _origin.
         self.const_unification_table
             .borrow_mut()
             .new_key(None)

src/librustc/ty/context.rs

@@ -51,7 +51,6 @@ use ty::query;
 use ty::steal::Steal;
 use ty::BindingMode;
 use ty::CanonicalTy;
-use ty::fold::TypeFoldable;
 use util::nodemap::{DefIdSet, ItemLocalMap};
 use util::nodemap::{FxHashMap, FxHashSet};
 use rustc_data_structures::accumulate_vec::AccumulateVec;
@@ -2277,11 +2276,8 @@ pub fn keep_local<'tcx, T: ty::TypeFoldable<'tcx>>(x: &T) -> bool {
 
 direct_interners!('tcx,
     region: mk_region(|r: &RegionKind| r.keep_in_local_tcx()) -> RegionKind,
-    // TODO(const_generics): self.has_type_flags(TypeFlags::HAS_CT_INFER)
-    const_: mk_const(|c: &Const| {
-        assert!(c.ty.is_global(), "mk_const({:?}): non-global type", c);
-        keep_local(&c.ty) || keep_local(&c.val)
-    }) -> Const<'tcx>
+    // TODO(const_generics): we might want to change this.
+    const_: mk_const(|c: &Const| keep_local(&c.ty) || keep_local(&c.val)) -> Const<'tcx>
 );
 
 macro_rules! slice_interners {

src/librustc/ty/relate.rs

@@ -478,8 +478,8 @@ pub fn super_relate_tys<'a, 'gcx, 'tcx, R>(relation: &mut R,
                     return Ok(s);
                 }
                 match x.val {
+                    // TODO(const_generics): make sure this works.
                     ConstValue::Unevaluated(def_id, substs) => {
-                        // TODO(const_generics)
                         // FIXME(eddyb) get the right param_env.
                         let param_env = ty::ParamEnv::empty();
                         match tcx.lift_to_global(&substs) {
@@ -493,7 +493,7 @@ pub fn super_relate_tys<'a, 'gcx, 'tcx, R>(relation: &mut R,
                                 if let Some(instance) = instance {
                                     let cid = GlobalId {
                                         instance,
-                                        promoted: None
+                                        promoted: None,
                                     };
                                     if let Some(s) = tcx.const_eval(param_env.and(cid))
                                                         .ok()
@@ -598,7 +598,6 @@ pub fn super_relate_consts<'a, 'gcx, 'tcx, R>(relation: &mut R,
     // implement both `PartialEq` and `Eq`, corresponding to
     // `structural_match` types.
     // FIXME(const_generics): check for `structural_match` synthetic attribute.
-    // TODO(const_generics): possibly need indirection for ByRef?
     match (a.val, b.val) {
         (ConstValue::Infer(_), _) | (_, ConstValue::Infer(_)) => {
             // The caller should handle these cases!
@@ -609,6 +608,7 @@ pub fn super_relate_consts<'a, 'gcx, 'tcx, R>(relation: &mut R,
         }
         (ConstValue::Scalar(_), _) |
         (ConstValue::ScalarPair(..), _) |
+        // TODO(const_generics): possibly need indirection for ByRef?
         (ConstValue::ByRef(..), _)
             if a == b =>
         {

src/librustc/ty/sty.rs

@@ -114,7 +114,7 @@ pub enum TyKind<'tcx> {
     Str,
 
     /// An array with the given length. Written as `[T; n]`.
-    // TODO(const_generics): clean up handling of TyArray with const generics
+    // TODO(const_generics): clean up handling of Array with const generics
     Array(Ty<'tcx>, &'tcx ty::Const<'tcx>),
 
     /// The pointee of an array slice.  Written as `[T]`.

src/librustc/ty/subst.rs

@@ -505,7 +505,7 @@ impl<'a, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for SubstFolder<'a, 'gcx, 'tcx> {
         return t1;
     }
 
-    // TODO(const_generics): fold const?
+    // TODO(const_generics): do we need fold_const?
 }
 
 impl<'a, 'gcx, 'tcx> SubstFolder<'a, 'gcx, 'tcx> {

src/librustc_mir/interpret/eval_context.rs

@@ -391,7 +391,6 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
             self.param_env,
             &substs,
         );
-        // TODO(const_generics): should bug!() on Infer and error on Param
         ty::Instance::resolve(
             *self.tcx,
             self.param_env,

src/librustc_typeck/check/mod.rs

@@ -5187,7 +5187,9 @@ pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
         ty
     );
 
-    if own_counts.types + own_counts.consts == 0 {
+    // TODO(const_generics): we probably want to check the bounds for const parameters too.
+
+    if own_counts.types == 0 {
         return;
     }
 
@@ -5219,24 +5221,6 @@ pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                 .emit();
         }
     }
-
-    // TODO(const_generics): is there even a way to walk all consts?
-    // let mut consts_used = vec![false; own_counts.types];
-
-    // let consts = generics.params.iter().filter(|param| match param.kind {
-    //    ty::GenericParamDefKind::Const => true,
-    //    _ => false,
-    // });
-    // for (&used, param) in consts_used.iter().zip(consts) {
-    //    if !used {
-    //        let id = tcx.hir.as_local_node_id(param.def_id).unwrap();
-    //        let span = tcx.hir.span(id);
-    //        // TODO(const_generics): new error code
-    //        struct_span_err!(tcx.sess, span, E0091, "const parameter `{}` is unused", param.name)
-    //            .span_label(span, "unused const parameter")
-    //            .emit();
-    //    }
-    // }
 }
 
 fn fatally_break_rust(sess: &Session) {

src/librustc_typeck/check/wfcheck.rs

@@ -829,9 +829,9 @@ fn check_variances_for_type_defn<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                     .collect();
 
     identify_constrained_type_params(tcx,
-                                        ty_predicates.predicates.as_slice(),
-                                        None,
-                                        &mut constrained_parameters);
+                                     ty_predicates.predicates.as_slice(),
+                                     None,
+                                     &mut constrained_parameters);
 
     for (index, _) in variances.iter().enumerate() {
         if constrained_parameters.contains(&Parameter(index as u32)) {

src/librustc_typeck/constrained_type_params.rs

@@ -93,7 +93,6 @@ impl<'tcx> TypeVisitor<'tcx> for ParameterCollector {
     fn visit_const(&mut self, c: &'tcx ty::Const<'tcx>) -> bool {
         match c.val {
             ConstValue::Param(data) => {
-                debug!("ParameterCollector::visit_const: visit const param: {}", data);
                 self.parameters.push(Parameter::from(data));
             }
             _ => {}

src/librustc_typeck/impl_wf_check.rs

@@ -136,15 +136,13 @@ 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
-                // let param_ct = ty::ParamConst::for_def(param);
-                // if !input_parameters.contains(&ctp::Parameter::from(param_ct)) {
-                //    report_unused_parameter(tcx,
-                //                            tcx.def_span(param.def_id),
-                //                            "const",
-                //                            &param_ct.to_string());
-                // }
+                let param_ct = ty::ParamConst::for_def(param);
+                if !input_parameters.contains(&ctp::Parameter::from(param_ct)) {
+                   report_unused_parameter(tcx,
+                                           tcx.def_span(param.def_id),
+                                           "const",
+                                           &param_ct.to_string());
+                }
             }
         }
     }

src/libsyntax/parse/parser.rs

@@ -5827,8 +5827,6 @@ impl<'a> Parser<'a> {
         }
     }
 
-    // TODO(const_generics): const generics introduces expressions to the list of
-    // things we can see after '<'.
     fn choose_generics_over_qpath(&self, param: bool) -> bool {
         // There's an ambiguity between generic parameters and qualified paths in impls.
         // If we see `<` it may start both, so we have to inspect some following tokens.