From 5acd1fa992f78451b6cdc00b1dbf6782e338b10f Mon Sep 17 00:00:00 2001
From: Nathan Ringo <remexre@gmail.com>
Date: Sat, 2 Jun 2018 22:02:40 -0500
Subject: [PATCH] Fixes for rust-lang/rust#51117.

---
 src/bin/cli/main.rs |  1 -
 src/typeck/reify.rs |  2 +-
 src/typeck/subst.rs | 36 +++++++++++++++++++++++-------------
 3 files changed, 24 insertions(+), 15 deletions(-)

diff --git a/src/bin/cli/main.rs b/src/bin/cli/main.rs
index beaa6ab..8f854eb 100644
--- a/src/bin/cli/main.rs
+++ b/src/bin/cli/main.rs
@@ -1,5 +1,4 @@
 extern crate evaltrees;
-#[macro_use]
 extern crate failure;
 #[cfg(not(debug_assertions))]
 #[macro_use]
diff --git a/src/typeck/reify.rs b/src/typeck/reify.rs
index ef0fe35..663c128 100644
--- a/src/typeck/reify.rs
+++ b/src/typeck/reify.rs
@@ -11,7 +11,7 @@ impl Decl<Ty> {
             arg.collect_vars(&mut vars);
         }
 
-        let mut env = vars.into_iter().collect::<Vec<_>>();
+        let env = vars.into_iter().collect::<Vec<_>>();
         let mut ty = self.aux.reify_in(&env);
         for _ in &env {
             ty = Type::Forall(Box::new(ty));
diff --git a/src/typeck/subst.rs b/src/typeck/subst.rs
index c6ab944..1ad103c 100644
--- a/src/typeck/subst.rs
+++ b/src/typeck/subst.rs
@@ -49,32 +49,42 @@ impl Substitution {
 impl Ty {
     /// Applies a substitution to the type.
     pub fn apply_subst(&mut self, subst: &Substitution) {
-        match self {
-            Ty::Func(l, r) => {
+        let new_self = match *self {
+            Ty::Func(ref mut l, ref mut r) => {
                 l.apply_subst(subst);
                 r.apply_subst(subst);
+                None
             }
-            Ty::Int => {}
-            Ty::List(t) => t.apply_subst(subst),
-            Ty::Var(v) => if let Some(ty) = subst.get(*v) {
-                *self = ty;
-            },
+            Ty::Int => None,
+            Ty::List(ref mut t) => {
+                t.apply_subst(subst);
+                None
+            }
+            Ty::Var(v) => subst.get(v),
+        };
+        if let Some(new_self) = new_self {
+            *self = new_self;
         }
     }
 
     /// Applies a single replacement to the type.
     pub fn sub(&mut self, var: SubstVar, ty: &Ty) {
-        match self {
+        let new_self = match self {
             Ty::Func(l, r) => {
                 l.sub(var, ty);
                 r.sub(var, ty);
+                None
             }
-            Ty::Int => {}
-            Ty::List(t) => t.sub(var, ty),
-            Ty::Var(v) if *v == var => {
-                *self = ty.clone();
+            Ty::Int => None,
+            Ty::List(t) => {
+                t.sub(var, ty);
+                None
             }
-            Ty::Var(_) => {}
+            Ty::Var(v) if *v == var => Some(ty.clone()),
+            Ty::Var(_) => None,
+        };
+        if let Some(new_self) = new_self {
+            *self = new_self;
         }
     }
 }