diff --git a/src/consts.rs b/src/consts.rs
index 5e7cd200d0f..0c32dc5efad 100644
--- a/src/consts.rs
+++ b/src/consts.rs
@@ -154,8 +154,8 @@ impl PartialOrd for Constant {
 fn lit_to_constant(lit: &Lit_) -> Constant {
     match *lit {
         LitStr(ref is, style) => ConstantStr(is.to_string(), style),
-        LitBinary(ref blob) => ConstantBinary(blob.clone()),
         LitByte(b) => ConstantByte(b),
+        LitByteStr(ref s) => ConstantBinary(s.clone()),
         LitChar(c) => ConstantChar(c),
         LitInt(value, ty) => ConstantInt(value, ty),
         LitFloat(ref is, ty) => ConstantFloat(is.to_string(), ty.into()),
diff --git a/src/minmax.rs b/src/minmax.rs
index 2e4c9256657..d7a74aa8c8b 100644
--- a/src/minmax.rs
+++ b/src/minmax.rs
@@ -1,11 +1,10 @@
 use rustc::lint::{Context, LintPass, LintArray};
 use rustc_front::hir::*;
-use syntax::codemap::Spanned;
 use syntax::ptr::P;
 use std::cmp::PartialOrd;
 use std::cmp::Ordering::*;
 
-use consts::{Constant, constant};
+use consts::{Constant, constant_simple};
 use utils::{match_path, span_lint};
 use self::MinMax::{Min, Max};
 
@@ -22,8 +21,8 @@ impl LintPass for MinMaxPass {
     }
 
     fn check_expr(&mut self, cx: &Context, expr: &Expr) {
-        if let Some((outer_max, outer_c, oe)) = min_max(cx, expr) {
-            if let Some((inner_max, inner_c, _)) = min_max(cx, oe) {
+        if let Some((outer_max, outer_c, oe)) = min_max(expr) {
+            if let Some((inner_max, inner_c, _)) = min_max(oe) {
                 if outer_max == inner_max { return; }
                 match (outer_max, outer_c.partial_cmp(&inner_c)) {
                     (_, None) | (Max, Some(Less)) | (Min, Some(Greater)) => (),
@@ -43,47 +42,31 @@ enum MinMax {
     Max,
 }
 
-fn min_max<'e>(cx: &Context, expr: &'e Expr) ->
-        Option<(MinMax, Constant, &'e Expr)> {
-    match expr.node {
-        ExprMethodCall(Spanned{node: ref ident, ..}, _, ref args) => {
-            let name = ident.name;
-            if name == "min" {
-                fetch_const(cx, args, Min)
+fn min_max(expr: &Expr) -> Option<(MinMax, Constant, &Expr)> {
+    if let ExprCall(ref path, ref args) = expr.node {
+        if let ExprPath(None, ref path) = path.node {
+            if match_path(path, &["std", "cmp", "min"]) {
+                fetch_const(args, Min)
             } else {
-                if name == "max" {
-                    fetch_const(cx, args, Max)
+                if match_path(path, &["std", "cmp", "max"]) {
+                    fetch_const(args, Max)
                 } else {
                     None
                 }
             }
-        },
-        ExprCall(ref path, ref args) => {
-            if let &ExprPath(None, ref path) = &path.node {
-                if match_path(path, &["min"]) {
-                    fetch_const(cx, args, Min)
-                } else {
-                    if match_path(path, &["max"]) {
-                        fetch_const(cx, args, Max)
-                    } else {
-                        None
-                    }
-                }
-            } else { None }
-         },
-         _ => None,
-     }
+        } else { None }
+    } else { None }
  }
 
-fn fetch_const<'e>(cx: &Context, args: &'e Vec<P<Expr>>, m: MinMax) ->
-        Option<(MinMax, Constant, &'e Expr)> {
+fn fetch_const(args: &[P<Expr>], m: MinMax) ->
+        Option<(MinMax, Constant, &Expr)> {
     if args.len() != 2 { return None }
-    if let Some((c, _)) = constant(cx, &args[0]) {
-        if let None = constant(cx, &args[1]) { // otherwise ignore
+    if let Some(c) = constant_simple(&args[0]) {
+        if let None = constant_simple(&args[1]) { // otherwise ignore
             Some((m, c, &args[1]))
         } else { None }
     } else {
-        if let Some((c, _)) = constant(cx, &args[1]) {
+        if let Some(c) = constant_simple(&args[1]) {
             Some((m, c, &args[0]))
         } else { None }
     }