Address review comments

Author: oli-obk

src/librustc/ich/impls_ty.rs

@@ -570,7 +570,7 @@ for ::mir::interpret::EvalErrorKind<'gcx, O> {
             ReadFromReturnPointer |
             UnimplementedTraitSelection |
             TypeckError |
-            ResolutionFailed |
+            TooGeneric |
             CheckMatchError |
             DerefFunctionPointer |
             ExecuteMemory |

src/librustc/middle/const_val.rs

@@ -101,7 +101,7 @@ impl<'a, 'gcx, 'tcx> ConstEvalErr<'tcx> {
     ) -> Option<DiagnosticBuilder<'tcx>> {
         match self.data.0.kind {
             ::mir::interpret::EvalErrorKind::TypeckError |
-            ::mir::interpret::EvalErrorKind::ResolutionFailed |
+            ::mir::interpret::EvalErrorKind::TooGeneric |
             ::mir::interpret::EvalErrorKind::CheckMatchError |
             ::mir::interpret::EvalErrorKind::Layout(_) => return None,
             ::mir::interpret::EvalErrorKind::ReferencedConstant(ref inner) => {

src/librustc/mir/interpret/error.rs

@@ -151,7 +151,7 @@ pub enum EvalErrorKind<'tcx, O> {
     /// Abort in case type errors are reached
     TypeckError,
     /// Resolution can fail if we are in a too generic context
-    ResolutionFailed,
+    TooGeneric,
     CheckMatchError,
     /// Cannot compute this constant because it depends on another one
     /// which already produced an error
@@ -271,7 +271,7 @@ impl<'tcx, O> EvalErrorKind<'tcx, O> {
                 "there were unresolved type arguments during trait selection",
             TypeckError =>
                 "encountered constants with type errors, stopping evaluation",
-            ResolutionFailed =>
+            TooGeneric =>
                 "encountered overly generic constant",
             CheckMatchError =>
                 "match checking failed",

src/librustc/traits/fulfill.rs

@@ -499,11 +499,11 @@ impl<'a, 'b, 'gcx, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'b, 'gcx,
                                             CodeSelectionError(ConstEvalFailure(err)))
                                     }
                                 } else {
-                                    let err = EvalErrorKind::ResolutionFailed.into();
+                                    let err = EvalErrorKind::TooGeneric.into();
                                     ProcessResult::Error(
                                         CodeSelectionError(ConstEvalFailure(ConstEvalErr {
                                             span: obligation.cause.span,
-                                            data: (err, Vec::new()).into(),
+                                            data: (err, vec![]).into(),
                                         }))
                                     )
                                 }

src/librustc/ty/structural_impls.rs

@@ -577,7 +577,7 @@ impl<'a, 'tcx, O: Lift<'tcx>> Lift<'tcx> for interpret::EvalErrorKind<'a, O> {
             PathNotFound(ref v) => PathNotFound(v.clone()),
             UnimplementedTraitSelection => UnimplementedTraitSelection,
             TypeckError => TypeckError,
-            ResolutionFailed => ResolutionFailed,
+            TooGeneric => TooGeneric,
             CheckMatchError => CheckMatchError,
             ReferencedConstant(ref err) => ReferencedConstant(tcx.lift(err)?),
             OverflowNeg => OverflowNeg,

src/librustc_mir/interpret/eval_context.rs

@@ -280,7 +280,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
             self.param_env,
             def_id,
             substs,
-        ).ok_or_else(|| EvalErrorKind::ResolutionFailed.into())
+        ).ok_or_else(|| EvalErrorKind::TooGeneric.into())
     }
 
     pub(super) fn type_is_sized(&self, ty: Ty<'tcx>) -> bool {
@@ -739,7 +739,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
                                     self.param_env,
                                     def_id,
                                     substs,
-                                ).ok_or_else(|| EvalErrorKind::ResolutionFailed.into());
+                                ).ok_or_else(|| EvalErrorKind::TooGeneric.into());
                                 let fn_ptr = self.memory.create_fn_alloc(instance?);
                                 let valty = ValTy {
                                     value: Value::Scalar(fn_ptr.into()),