Remove largely unused context from Visitor.

1 files changed, 281 insertions, 325 deletions

diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
index 50b42ea2c0f..c31082ddf59 100644
--- a/src/libsyntax/visit.rs
+++ b/src/libsyntax/visit.rs
@@ -8,11 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Context-passing AST walker. Each overridden visit method has full control
-//! over what happens with its node, it can do its own traversal of the node's
-//! children (potentially passing in different contexts to each), call
-//! `visit::visit_*` to apply the default traversal algorithm (again, it can
-//! override the context), or prevent deeper traversal by doing nothing.
+//! AST walker. Each overridden visit method has full control over what
+//! happens with its node, it can do its own traversal of the node's children,
+//! call `visit::walk_*` to apply the default traversal algorithm, or prevent
+//! deeper traversal by doing nothing.
 //!
 //! Note: it is an important invariant that the default visitor walks the body
 //! of a function in "execution order" (more concretely, reverse post-order
@@ -72,85 +71,82 @@ pub fn generics_of_fn(fk: &FnKind) -> Generics {
 /// explicitly, you need to override each method.  (And you also need
 /// to monitor future changes to `Visitor` in case a new method with a
 /// new default implementation gets introduced.)
-pub trait Visitor<E: Clone> {
+pub trait Visitor {
 
-    fn visit_ident(&mut self, _sp: Span, _ident: Ident, _e: E) {
+    fn visit_ident(&mut self, _sp: Span, _ident: Ident) {
         /*! Visit the idents */
     }
-    fn visit_mod(&mut self, m: &Mod, _s: Span, _n: NodeId, e: E) { walk_mod(self, m, e) }
-    fn visit_view_item(&mut self, i: &ViewItem, e: E) { walk_view_item(self, i, e) }
-    fn visit_foreign_item(&mut self, i: &ForeignItem, e: E) { walk_foreign_item(self, i, e) }
-    fn visit_item(&mut self, i: &Item, e: E) { walk_item(self, i, e) }
-    fn visit_local(&mut self, l: &Local, e: E) { walk_local(self, l, e) }
-    fn visit_block(&mut self, b: &Block, e: E) { walk_block(self, b, e) }
-    fn visit_stmt(&mut self, s: &Stmt, e: E) { walk_stmt(self, s, e) }
-    fn visit_arm(&mut self, a: &Arm, e: E) { walk_arm(self, a, e) }
-    fn visit_pat(&mut self, p: &Pat, e: E) { walk_pat(self, p, e) }
-    fn visit_decl(&mut self, d: &Decl, e: E) { walk_decl(self, d, e) }
-    fn visit_expr(&mut self, ex: &Expr, e: E) { walk_expr(self, ex, e) }
-    fn visit_expr_post(&mut self, _ex: &Expr, _e: E) { }
-    fn visit_ty(&mut self, t: &Ty, e: E) { walk_ty(self, t, e) }
-    fn visit_generics(&mut self, g: &Generics, e: E) { walk_generics(self, g, e) }
-    fn visit_fn(&mut self, fk: &FnKind, fd: &FnDecl, b: &Block, s: Span, _: NodeId, e: E) {
-        walk_fn(self, fk, fd, b, s, e)
-    }
-    fn visit_ty_method(&mut self, t: &TypeMethod, e: E) { walk_ty_method(self, t, e) }
-    fn visit_trait_item(&mut self, t: &TraitItem, e: E) { walk_trait_item(self, t, e) }
-    fn visit_struct_def(&mut self, s: &StructDef, _: Ident, _: &Generics, _: NodeId, e: E) {
-        walk_struct_def(self, s, e)
-    }
-    fn visit_struct_field(&mut self, s: &StructField, e: E) { walk_struct_field(self, s, e) }
-    fn visit_variant(&mut self, v: &Variant, g: &Generics, e: E) { walk_variant(self, v, g, e) }
+    fn visit_mod(&mut self, m: &Mod, _s: Span, _n: NodeId) { walk_mod(self, m) }
+    fn visit_view_item(&mut self, i: &ViewItem) { walk_view_item(self, i) }
+    fn visit_foreign_item(&mut self, i: &ForeignItem) { walk_foreign_item(self, i) }
+    fn visit_item(&mut self, i: &Item) { walk_item(self, i) }
+    fn visit_local(&mut self, l: &Local) { walk_local(self, l) }
+    fn visit_block(&mut self, b: &Block) { walk_block(self, b) }
+    fn visit_stmt(&mut self, s: &Stmt) { walk_stmt(self, s) }
+    fn visit_arm(&mut self, a: &Arm) { walk_arm(self, a) }
+    fn visit_pat(&mut self, p: &Pat) { walk_pat(self, p) }
+    fn visit_decl(&mut self, d: &Decl) { walk_decl(self, d) }
+    fn visit_expr(&mut self, ex: &Expr) { walk_expr(self, ex) }
+    fn visit_expr_post(&mut self, _ex: &Expr) { }
+    fn visit_ty(&mut self, t: &Ty) { walk_ty(self, t) }
+    fn visit_generics(&mut self, g: &Generics) { walk_generics(self, g) }
+    fn visit_fn(&mut self, fk: &FnKind, fd: &FnDecl, b: &Block, s: Span, _: NodeId) {
+        walk_fn(self, fk, fd, b, s)
+    }
+    fn visit_ty_method(&mut self, t: &TypeMethod) { walk_ty_method(self, t) }
+    fn visit_trait_item(&mut self, t: &TraitItem) { walk_trait_item(self, t) }
+    fn visit_struct_def(&mut self, s: &StructDef, _: Ident, _: &Generics, _: NodeId) {
+        walk_struct_def(self, s)
+    }
+    fn visit_struct_field(&mut self, s: &StructField) { walk_struct_field(self, s) }
+    fn visit_variant(&mut self, v: &Variant, g: &Generics) { walk_variant(self, v, g) }
     fn visit_opt_lifetime_ref(&mut self,
                               _span: Span,
-                              opt_lifetime: &Option<Lifetime>,
-                              env: E) {
+                              opt_lifetime: &Option<Lifetime>) {
         /*!
          * Visits an optional reference to a lifetime. The `span` is
          * the span of some surrounding reference should opt_lifetime
          * be None.
          */
         match *opt_lifetime {
-            Some(ref l) => self.visit_lifetime_ref(l, env),
+            Some(ref l) => self.visit_lifetime_ref(l),
             None => ()
         }
     }
-    fn visit_lifetime_ref(&mut self, _lifetime: &Lifetime, _e: E) {
+    fn visit_lifetime_ref(&mut self, _lifetime: &Lifetime) {
         /*! Visits a reference to a lifetime */
     }
-    fn visit_lifetime_decl(&mut self, _lifetime: &LifetimeDef, _e: E) {
+    fn visit_lifetime_decl(&mut self, _lifetime: &LifetimeDef) {
         /*! Visits a declaration of a lifetime */
     }
-    fn visit_explicit_self(&mut self, es: &ExplicitSelf, e: E) {
-        walk_explicit_self(self, es, e)
+    fn visit_explicit_self(&mut self, es: &ExplicitSelf) {
+        walk_explicit_self(self, es)
     }
-    fn visit_mac(&mut self, _macro: &Mac, _e: E) {
+    fn visit_mac(&mut self, _macro: &Mac) {
         fail!("visit_mac disabled by default");
         // NB: see note about macros above.
         // if you really want a visitor that
         // works on macros, use this
         // definition in your trait impl:
-        // visit::walk_mac(self, _macro, _e)
+        // visit::walk_mac(self, _macro)
     }
-    fn visit_path(&mut self, path: &Path, _id: ast::NodeId, e: E) {
-        walk_path(self, path, e)
+    fn visit_path(&mut self, path: &Path, _id: ast::NodeId) {
+        walk_path(self, path)
     }
-    fn visit_attribute(&mut self, _attr: &Attribute, _e: E) {}
+    fn visit_attribute(&mut self, _attr: &Attribute) {}
 }
 
-pub fn walk_inlined_item<E: Clone, V: Visitor<E>>(visitor: &mut V,
-                                                  item: &ast::InlinedItem,
-                                                  env: E) {
+pub fn walk_inlined_item<V: Visitor>(visitor: &mut V, item: &ast::InlinedItem) {
     match *item {
-        IIItem(i) => visitor.visit_item(&*i, env),
-        IIForeign(i) => visitor.visit_foreign_item(&*i, env),
+        IIItem(i) => visitor.visit_item(&*i),
+        IIForeign(i) => visitor.visit_foreign_item(&*i),
         IITraitItem(_, iti) => {
             match iti {
                 ProvidedInlinedTraitItem(m) => {
-                    walk_method_helper(visitor, &*m, env)
+                    walk_method_helper(visitor, &*m)
                 }
                 RequiredInlinedTraitItem(m) => {
-                    walk_method_helper(visitor, &*m, env)
+                    walk_method_helper(visitor, &*m)
                 }
             }
         }
@@ -158,637 +154,600 @@ pub fn walk_inlined_item<E: Clone, V: Visitor<E>>(visitor: &mut V,
 }
 
 
-pub fn walk_crate<E: Clone, V: Visitor<E>>(visitor: &mut V, krate: &Crate, env: E) {
-    visitor.visit_mod(&krate.module, krate.span, CRATE_NODE_ID, env.clone());
+pub fn walk_crate<V: Visitor>(visitor: &mut V, krate: &Crate) {
+    visitor.visit_mod(&krate.module, krate.span, CRATE_NODE_ID);
     for attr in krate.attrs.iter() {
-        visitor.visit_attribute(attr, env.clone());
+        visitor.visit_attribute(attr);
     }
 }
 
-pub fn walk_mod<E: Clone, V: Visitor<E>>(visitor: &mut V, module: &Mod, env: E) {
+pub fn walk_mod<V: Visitor>(visitor: &mut V, module: &Mod) {
     for view_item in module.view_items.iter() {
-        visitor.visit_view_item(view_item, env.clone())
+        visitor.visit_view_item(view_item)
     }
 
     for item in module.items.iter() {
-        visitor.visit_item(&**item, env.clone())
+        visitor.visit_item(&**item)
     }
 }
 
-pub fn walk_view_item<E: Clone, V: Visitor<E>>(visitor: &mut V, vi: &ViewItem, env: E) {
+pub fn walk_view_item<V: Visitor>(visitor: &mut V, vi: &ViewItem) {
     match vi.node {
         ViewItemExternCrate(name, _, _) => {
-            visitor.visit_ident(vi.span, name, env.clone())
+            visitor.visit_ident(vi.span, name)
         }
         ViewItemUse(ref vp) => {
             match vp.node {
                 ViewPathSimple(ident, ref path, id) => {
-                    visitor.visit_ident(vp.span, ident, env.clone());
-                    visitor.visit_path(path, id, env.clone());
+                    visitor.visit_ident(vp.span, ident);
+                    visitor.visit_path(path, id);
                 }
                 ViewPathGlob(ref path, id) => {
-                    visitor.visit_path(path, id, env.clone());
+                    visitor.visit_path(path, id);
                 }
                 ViewPathList(ref path, ref list, _) => {
                     for id in list.iter() {
                         match id.node {
                             PathListIdent { name, .. } => {
-                                visitor.visit_ident(id.span, name, env.clone());
+                                visitor.visit_ident(id.span, name);
                             }
                             PathListMod { .. } => ()
                         }
                     }
-                    walk_path(visitor, path, env.clone());
+                    walk_path(visitor, path);
                 }
             }
         }
     }
     for attr in vi.attrs.iter() {
-        visitor.visit_attribute(attr, env.clone());
+        visitor.visit_attribute(attr);
     }
 }
 
-pub fn walk_local<E: Clone, V: Visitor<E>>(visitor: &mut V, local: &Local, env: E) {
-    visitor.visit_pat(&*local.pat, env.clone());
-    visitor.visit_ty(&*local.ty, env.clone());
+pub fn walk_local<V: Visitor>(visitor: &mut V, local: &Local) {
+    visitor.visit_pat(&*local.pat);
+    visitor.visit_ty(&*local.ty);
     match local.init {
         None => {}
-        Some(initializer) => visitor.visit_expr(&*initializer, env),
+        Some(initializer) => visitor.visit_expr(&*initializer),
     }
 }
 
-pub fn walk_explicit_self<E: Clone, V: Visitor<E>>(visitor: &mut V,
-                                                   explicit_self: &ExplicitSelf,
-                                                   env: E) {
+pub fn walk_explicit_self<V: Visitor>(visitor: &mut V, explicit_self: &ExplicitSelf) {
     match explicit_self.node {
         SelfStatic | SelfValue(_) => {},
         SelfRegion(ref lifetime, _, _) => {
-            visitor.visit_opt_lifetime_ref(explicit_self.span, lifetime, env)
+            visitor.visit_opt_lifetime_ref(explicit_self.span, lifetime)
         }
-        SelfExplicit(ref typ, _) => visitor.visit_ty(&**typ, env.clone()),
+        SelfExplicit(ref typ, _) => visitor.visit_ty(&**typ),
     }
 }
 
 /// Like with walk_method_helper this doesn't correspond to a method
 /// in Visitor, and so it gets a _helper suffix.
-pub fn walk_trait_ref_helper<E: Clone, V: Visitor<E>>(visitor: &mut V,
-                                                      trait_ref: &TraitRef,
-                                                      env: E) {
-    visitor.visit_path(&trait_ref.path, trait_ref.ref_id, env)
+pub fn walk_trait_ref_helper<V: Visitor>(visitor: &mut V, trait_ref: &TraitRef) {
+    visitor.visit_path(&trait_ref.path, trait_ref.ref_id)
 }
 
-pub fn walk_item<E: Clone, V: Visitor<E>>(visitor: &mut V, item: &Item, env: E) {
-    visitor.visit_ident(item.span, item.ident, env.clone());
+pub fn walk_item<V: Visitor>(visitor: &mut V, item: &Item) {
+    visitor.visit_ident(item.span, item.ident);
     match item.node {
         ItemStatic(ref typ, _, ref expr) => {
-            visitor.visit_ty(&**typ, env.clone());
-            visitor.visit_expr(&**expr, env.clone());
+            visitor.visit_ty(&**typ);
+            visitor.visit_expr(&**expr);
         }
         ItemFn(declaration, fn_style, abi, ref generics, body) => {
             visitor.visit_fn(&FkItemFn(item.ident, generics, fn_style, abi),
                              &*declaration,
                              &*body,
                              item.span,
-                             item.id,
-                             env.clone())
+                             item.id)
         }
         ItemMod(ref module) => {
-            visitor.visit_mod(module, item.span, item.id, env.clone())
+            visitor.visit_mod(module, item.span, item.id)
         }
         ItemForeignMod(ref foreign_module) => {
             for view_item in foreign_module.view_items.iter() {
-                visitor.visit_view_item(view_item, env.clone())
+                visitor.visit_view_item(view_item)
             }
             for foreign_item in foreign_module.items.iter() {
-                visitor.visit_foreign_item(&**foreign_item, env.clone())
+                visitor.visit_foreign_item(&**foreign_item)
             }
         }
         ItemTy(ref typ, ref type_parameters) => {
-            visitor.visit_ty(&**typ, env.clone());
-            visitor.visit_generics(type_parameters, env.clone())
+            visitor.visit_ty(&**typ);
+            visitor.visit_generics(type_parameters)
         }
         ItemEnum(ref enum_definition, ref type_parameters) => {
-            visitor.visit_generics(type_parameters, env.clone());
-            walk_enum_def(visitor, enum_definition, type_parameters, env.clone())
+            visitor.visit_generics(type_parameters);
+            walk_enum_def(visitor, enum_definition, type_parameters)
         }
         ItemImpl(ref type_parameters,
                  ref trait_reference,
                  typ,
                  ref impl_items) => {
-            visitor.visit_generics(type_parameters, env.clone());
+            visitor.visit_generics(type_parameters);
             match *trait_reference {
                 Some(ref trait_reference) => walk_trait_ref_helper(visitor,
-                                                                   trait_reference, env.clone()),
+                                                                   trait_reference),
                 None => ()
             }
-            visitor.visit_ty(&*typ, env.clone());
+            visitor.visit_ty(&*typ);
             for impl_item in impl_items.iter() {
                 match *impl_item {
                     MethodImplItem(method) => {
-                        walk_method_helper(visitor, &*method, env.clone())
+                        walk_method_helper(visitor, &*method)
                     }
                 }
             }
         }
         ItemStruct(ref struct_definition, ref generics) => {
-            visitor.visit_generics(generics, env.clone());
+            visitor.visit_generics(generics);
             visitor.visit_struct_def(&**struct_definition,
                                      item.ident,
                                      generics,
-                                     item.id,
-                                     env.clone())
+                                     item.id)
         }
         ItemTrait(ref generics, _, ref bounds, ref methods) => {
-            visitor.visit_generics(generics, env.clone());
-            walk_ty_param_bounds(visitor, bounds, env.clone());
+            visitor.visit_generics(generics);
+            walk_ty_param_bounds(visitor, bounds);
             for method in methods.iter() {
-                visitor.visit_trait_item(method, env.clone())
+                visitor.visit_trait_item(method)
             }
         }
-        ItemMac(ref macro) => visitor.visit_mac(macro, env.clone()),
+        ItemMac(ref macro) => visitor.visit_mac(macro),
     }
     for attr in item.attrs.iter() {
-        visitor.visit_attribute(attr, env.clone());
+        visitor.visit_attribute(attr);
     }
 }
 
-pub fn walk_enum_def<E: Clone, V:Visitor<E>>(visitor: &mut V,
-                                             enum_definition: &EnumDef,
-                                             generics: &Generics,
-                                             env: E) {
+pub fn walk_enum_def<V: Visitor>(visitor: &mut V,
+                                 enum_definition: &EnumDef,
+                                 generics: &Generics) {
     for &variant in enum_definition.variants.iter() {
-        visitor.visit_variant(&*variant, generics, env.clone());
+        visitor.visit_variant(&*variant, generics);
     }
 }
 
-pub fn walk_variant<E: Clone, V: Visitor<E>>(visitor: &mut V,
-                                             variant: &Variant,
-                                             generics: &Generics,
-                                             env: E) {
-    visitor.visit_ident(variant.span, variant.node.name, env.clone());
+pub fn walk_variant<V: Visitor>(visitor: &mut V,
+                                variant: &Variant,
+                                generics: &Generics) {
+    visitor.visit_ident(variant.span, variant.node.name);
 
     match variant.node.kind {
         TupleVariantKind(ref variant_arguments) => {
             for variant_argument in variant_arguments.iter() {
-                visitor.visit_ty(&*variant_argument.ty, env.clone())
+                visitor.visit_ty(&*variant_argument.ty)
             }
         }
         StructVariantKind(ref struct_definition) => {
             visitor.visit_struct_def(&**struct_definition,
                                      variant.node.name,
                                      generics,
-                                     variant.node.id,
-                                     env.clone())
+                                     variant.node.id)
         }
     }
     match variant.node.disr_expr {
-        Some(ref expr) => visitor.visit_expr(&**expr, env.clone()),
+        Some(ref expr) => visitor.visit_expr(&**expr),
         None => ()
     }
     for attr in variant.node.attrs.iter() {
-        visitor.visit_attribute(attr, env.clone());
+        visitor.visit_attribute(attr);
     }
 }
 
-pub fn skip_ty<E, V: Visitor<E>>(_: &mut V, _: &Ty, _: E) {
+pub fn skip_ty<V: Visitor>(_: &mut V, _: &Ty) {
     // Empty!
 }
 
-pub fn walk_ty<E: Clone, V: Visitor<E>>(visitor: &mut V, typ: &Ty, env: E) {
+pub fn walk_ty<V: Visitor>(visitor: &mut V, typ: &Ty) {
     match typ.node {
         TyUniq(ty) | TyVec(ty) | TyBox(ty) | TyParen(ty) => {
-            visitor.visit_ty(&*ty, env)
+            visitor.visit_ty(&*ty)
         }
         TyPtr(ref mutable_type) => {
-            visitor.visit_ty(&*mutable_type.ty, env)
+            visitor.visit_ty(&*mutable_type.ty)
         }
         TyRptr(ref lifetime, ref mutable_type) => {
-            visitor.visit_opt_lifetime_ref(typ.span, lifetime, env.clone());
-            visitor.visit_ty(&*mutable_type.ty, env)
+            visitor.visit_opt_lifetime_ref(typ.span, lifetime);
+            visitor.visit_ty(&*mutable_type.ty)
         }
         TyTup(ref tuple_element_types) => {
             for &tuple_element_type in tuple_element_types.iter() {
-                visitor.visit_ty(&*tuple_element_type, env.clone())
+                visitor.visit_ty(&*tuple_element_type)
             }
         }
         TyClosure(ref function_declaration) => {
             for argument in function_declaration.decl.inputs.iter() {
-                visitor.visit_ty(&*argument.ty, env.clone())
+                visitor.visit_ty(&*argument.ty)
             }
-            visitor.visit_ty(&*function_declaration.decl.output, env.clone());
-            walk_ty_param_bounds(visitor, &function_declaration.bounds,
-                                 env.clone());
-            walk_lifetime_decls(visitor, &function_declaration.lifetimes,
-                                env.clone());
+            visitor.visit_ty(&*function_declaration.decl.output);
+            walk_ty_param_bounds(visitor, &function_declaration.bounds);
+            walk_lifetime_decls(visitor, &function_declaration.lifetimes);
         }
         TyProc(ref function_declaration) => {
             for argument in function_declaration.decl.inputs.iter() {
-                visitor.visit_ty(&*argument.ty, env.clone())
+                visitor.visit_ty(&*argument.ty)
             }
-            visitor.visit_ty(&*function_declaration.decl.output, env.clone());
-            walk_ty_param_bounds(visitor, &function_declaration.bounds,
-                                 env.clone());
-            walk_lifetime_decls(visitor, &function_declaration.lifetimes,
-                                env.clone());
+            visitor.visit_ty(&*function_declaration.decl.output);
+            walk_ty_param_bounds(visitor, &function_declaration.bounds);
+            walk_lifetime_decls(visitor, &function_declaration.lifetimes);
         }
         TyBareFn(ref function_declaration) => {
             for argument in function_declaration.decl.inputs.iter() {
-                visitor.visit_ty(&*argument.ty, env.clone())
+                visitor.visit_ty(&*argument.ty)
             }
-            visitor.visit_ty(&*function_declaration.decl.output, env.clone());
-            walk_lifetime_decls(visitor, &function_declaration.lifetimes,
-                                env.clone());
+            visitor.visit_ty(&*function_declaration.decl.output);
+            walk_lifetime_decls(visitor, &function_declaration.lifetimes);
         }
         TyUnboxedFn(ref function_declaration) => {
             for argument in function_declaration.decl.inputs.iter() {
-                visitor.visit_ty(&*argument.ty, env.clone())
+                visitor.visit_ty(&*argument.ty)
             }
-            visitor.visit_ty(&*function_declaration.decl.output, env.clone());
+            visitor.visit_ty(&*function_declaration.decl.output);
         }
         TyPath(ref path, ref opt_bounds, id) => {
-            visitor.visit_path(path, id, env.clone());
+            visitor.visit_path(path, id);
             match *opt_bounds {
                 Some(ref bounds) => {
-                    walk_ty_param_bounds(visitor, bounds, env.clone());
+                    walk_ty_param_bounds(visitor, bounds);
                 }
                 None => { }
             }
         }
         TyFixedLengthVec(ref ty, ref expression) => {
-            visitor.visit_ty(&**ty, env.clone());
-            visitor.visit_expr(&**expression, env)
+            visitor.visit_ty(&**ty);
+            visitor.visit_expr(&**expression)
         }
         TyTypeof(ref expression) => {
-            visitor.visit_expr(&**expression, env)
+            visitor.visit_expr(&**expression)
         }
         TyNil | TyBot | TyInfer => {}
     }
 }
 
-fn walk_lifetime_decls<E: Clone, V: Visitor<E>>(visitor: &mut V,
-                                                lifetimes: &Vec<LifetimeDef>,
-                                                env: E) {
+fn walk_lifetime_decls<V: Visitor>(visitor: &mut V, lifetimes: &Vec<LifetimeDef>) {
     for l in lifetimes.iter() {
-        visitor.visit_lifetime_decl(l, env.clone());
+        visitor.visit_lifetime_decl(l);
     }
 }
 
-pub fn walk_path<E: Clone, V: Visitor<E>>(visitor: &mut V, path: &Path, env: E) {
+pub fn walk_path<V: Visitor>(visitor: &mut V, path: &Path) {
     for segment in path.segments.iter() {
-        visitor.visit_ident(path.span, segment.identifier, env.clone());
+        visitor.visit_ident(path.span, segment.identifier);
 
         for typ in segment.types.iter() {
-            visitor.visit_ty(&**typ, env.clone());
+            visitor.visit_ty(&**typ);
         }
         for lifetime in segment.lifetimes.iter() {
-            visitor.visit_lifetime_ref(lifetime, env.clone());
+            visitor.visit_lifetime_ref(lifetime);
         }
     }
 }
 
-pub fn walk_pat<E: Clone, V: Visitor<E>>(visitor: &mut V, pattern: &Pat, env: E) {
+pub fn walk_pat<V: Visitor>(visitor: &mut V, pattern: &Pat) {
     match pattern.node {
         PatEnum(ref path, ref children) => {
-            visitor.visit_path(path, pattern.id, env.clone());
+            visitor.visit_path(path, pattern.id);
             for children in children.iter() {
                 for child in children.iter() {
-                    visitor.visit_pat(&**child, env.clone())
+                    visitor.visit_pat(&**child)
                 }
             }
         }
         PatStruct(ref path, ref fields, _) => {
-            visitor.visit_path(path, pattern.id, env.clone());
+            visitor.visit_path(path, pattern.id);
             for field in fields.iter() {
-                visitor.visit_pat(&*field.pat, env.clone())
+                visitor.visit_pat(&*field.pat)
             }
         }
         PatTup(ref tuple_elements) => {
             for tuple_element in tuple_elements.iter() {
-                visitor.visit_pat(&**tuple_element, env.clone())
+                visitor.visit_pat(&**tuple_element)
             }
         }
         PatBox(ref subpattern) |
         PatRegion(ref subpattern) => {
-            visitor.visit_pat(&**subpattern, env)
+            visitor.visit_pat(&**subpattern)
         }
         PatIdent(_, ref pth1, ref optional_subpattern) => {
-            visitor.visit_ident(pth1.span, pth1.node, env.clone());
+            visitor.visit_ident(pth1.span, pth1.node);
             match *optional_subpattern {
                 None => {}
-                Some(ref subpattern) => visitor.visit_pat(&**subpattern, env),
+                Some(ref subpattern) => visitor.visit_pat(&**subpattern),
             }
         }
-        PatLit(ref expression) => visitor.visit_expr(&**expression, env),
+        PatLit(ref expression) => visitor.visit_expr(&**expression),
         PatRange(ref lower_bound, ref upper_bound) => {
-            visitor.visit_expr(&**lower_bound, env.clone());
-            visitor.visit_expr(&**upper_bound, env)
+            visitor.visit_expr(&**lower_bound);
+            visitor.visit_expr(&**upper_bound)
         }
         PatWild(_) => (),
         PatVec(ref prepattern, ref slice_pattern, ref postpatterns) => {
             for prepattern in prepattern.iter() {
-                visitor.visit_pat(&**prepattern, env.clone())
+                visitor.visit_pat(&**prepattern)
             }
             for slice_pattern in slice_pattern.iter() {
-                visitor.visit_pat(&**slice_pattern, env.clone())
+                visitor.visit_pat(&**slice_pattern)
             }
             for postpattern in postpatterns.iter() {
-                visitor.visit_pat(&**postpattern, env.clone())
+                visitor.visit_pat(&**postpattern)
             }
         }
-        PatMac(ref macro) => visitor.visit_mac(macro, env),
+        PatMac(ref macro) => visitor.visit_mac(macro),
     }
 }
 
-pub fn walk_foreign_item<E: Clone, V: Visitor<E>>(visitor: &mut V,
-                                                  foreign_item: &ForeignItem,
-                                                  env: E) {
-    visitor.visit_ident(foreign_item.span, foreign_item.ident, env.clone());
+pub fn walk_foreign_item<V: Visitor>(visitor: &mut V, foreign_item: &ForeignItem) {
+    visitor.visit_ident(foreign_item.span, foreign_item.ident);
 
     match foreign_item.node {
         ForeignItemFn(ref function_declaration, ref generics) => {
-            walk_fn_decl(visitor, &**function_declaration, env.clone());
-            visitor.visit_generics(generics, env.clone())
+            walk_fn_decl(visitor, &**function_declaration);
+            visitor.visit_generics(generics)
         }
-        ForeignItemStatic(ref typ, _) => visitor.visit_ty(&**typ, env.clone()),
+        ForeignItemStatic(ref typ, _) => visitor.visit_ty(&**typ),
     }
 
     for attr in foreign_item.attrs.iter() {
-        visitor.visit_attribute(attr, env.clone());
+        visitor.visit_attribute(attr);
     }
 }
 
-pub fn walk_ty_param_bounds<E: Clone, V: Visitor<E>>(visitor: &mut V,
-                                                     bounds: &OwnedSlice<TyParamBound>,
-                                                     env: E) {
+pub fn walk_ty_param_bounds<V: Visitor>(visitor: &mut V,
+                                        bounds: &OwnedSlice<TyParamBound>) {
     for bound in bounds.iter() {
         match *bound {
             TraitTyParamBound(ref typ) => {
-                walk_trait_ref_helper(visitor, typ, env.clone())
+                walk_trait_ref_helper(visitor, typ)
             }
             UnboxedFnTyParamBound(ref function_declaration) => {
                 for argument in function_declaration.decl.inputs.iter() {
-                    visitor.visit_ty(&*argument.ty, env.clone())
+                    visitor.visit_ty(&*argument.ty)
                 }
-                visitor.visit_ty(&*function_declaration.decl.output,
-                                 env.clone());
+                visitor.visit_ty(&*function_declaration.decl.output);
             }
             RegionTyParamBound(ref lifetime) => {
-                visitor.visit_lifetime_ref(lifetime, env.clone());
+                visitor.visit_lifetime_ref(lifetime);
             }
         }
     }
 }
 
-pub fn walk_generics<E: Clone, V: Visitor<E>>(visitor: &mut V,
-                                              generics: &Generics,
-                                              env: E) {
+pub fn walk_generics<V: Visitor>(visitor: &mut V, generics: &Generics) {
     for type_parameter in generics.ty_params.iter() {
-        walk_ty_param_bounds(visitor, &type_parameter.bounds, env.clone());
+        walk_ty_param_bounds(visitor, &type_parameter.bounds);
         match type_parameter.default {
-            Some(ref ty) => visitor.visit_ty(&**ty, env.clone()),
+            Some(ref ty) => visitor.visit_ty(&**ty),
             None => {}
         }
     }
-    walk_lifetime_decls(visitor, &generics.lifetimes, env.clone());
+    walk_lifetime_decls(visitor, &generics.lifetimes);
     for predicate in generics.where_clause.predicates.iter() {
-        visitor.visit_ident(predicate.span, predicate.ident, env.clone());
-        walk_ty_param_bounds(visitor, &predicate.bounds, env.clone());
+        visitor.visit_ident(predicate.span, predicate.ident);
+        walk_ty_param_bounds(visitor, &predicate.bounds);
     }
 }
 
-pub fn walk_fn_decl<E: Clone, V: Visitor<E>>(visitor: &mut V,
-                                             function_declaration: &FnDecl,
-                                             env: E) {
+pub fn walk_fn_decl<V: Visitor>(visitor: &mut V, function_declaration: &FnDecl) {
     for argument in function_declaration.inputs.iter() {
-        visitor.visit_pat(&*argument.pat, env.clone());
-        visitor.visit_ty(&*argument.ty, env.clone())
+        visitor.visit_pat(&*argument.pat);
+        visitor.visit_ty(&*argument.ty)
     }
-    visitor.visit_ty(&*function_declaration.output, env)
+    visitor.visit_ty(&*function_declaration.output)
 }
 
 // Note: there is no visit_method() method in the visitor, instead override
 // visit_fn() and check for FkMethod().  I named this visit_method_helper()
 // because it is not a default impl of any method, though I doubt that really
 // clarifies anything. - Niko
-pub fn walk_method_helper<E: Clone, V: Visitor<E>>(visitor: &mut V,
-                                                   method: &Method,
-                                                   env: E) {
+pub fn walk_method_helper<V: Visitor>(visitor: &mut V, method: &Method) {
     match method.node {
         MethDecl(ident, ref generics, _, _, _, decl, body, _) => {
-            visitor.visit_ident(method.span, ident, env.clone());
+            visitor.visit_ident(method.span, ident);
             visitor.visit_fn(&FkMethod(ident, generics, method),
                              &*decl,
                              &*body,
                              method.span,
-                             method.id,
-                             env.clone());
+                             method.id);
             for attr in method.attrs.iter() {
-                visitor.visit_attribute(attr, env.clone());
+                visitor.visit_attribute(attr);
             }
 
         },
-        MethMac(ref mac) => visitor.visit_mac(mac, env.clone())
+        MethMac(ref mac) => visitor.visit_mac(mac)
     }
 }
 
-pub fn walk_fn<E: Clone, V: Visitor<E>>(visitor: &mut V,
-                                        function_kind: &FnKind,
-                                        function_declaration: &FnDecl,
-                                        function_body: &Block,
-                                        _span: Span,
-                                        env: E) {
-    walk_fn_decl(visitor, function_declaration, env.clone());
+pub fn walk_fn<V: Visitor>(visitor: &mut V,
+                           function_kind: &FnKind,
+                           function_declaration: &FnDecl,
+                           function_body: &Block,
+                           _span: Span) {
+    walk_fn_decl(visitor, function_declaration);
 
     match *function_kind {
         FkItemFn(_, generics, _, _) => {
-            visitor.visit_generics(generics, env.clone());
+            visitor.visit_generics(generics);
         }
         FkMethod(_, generics, method) => {
-            visitor.visit_generics(generics, env.clone());
+            visitor.visit_generics(generics);
             match method.node {
                 MethDecl(_, _, _, ref explicit_self, _, _, _, _) =>
-                    visitor.visit_explicit_self(explicit_self, env.clone()),
+                    visitor.visit_explicit_self(explicit_self),
                 MethMac(ref mac) =>
-                    visitor.visit_mac(mac, env.clone())
+                    visitor.visit_mac(mac)
             }
         }
         FkFnBlock(..) => {}
     }
 
-    visitor.visit_block(function_body, env)
+    visitor.visit_block(function_body)
 }
 
-pub fn walk_ty_method<E: Clone, V: Visitor<E>>(visitor: &mut V,
-                                               method_type: &TypeMethod,
-                                               env: E) {
-    visitor.visit_ident(method_type.span, method_type.ident, env.clone());
-    visitor.visit_explicit_self(&method_type.explicit_self, env.clone());
+pub fn walk_ty_method<V: Visitor>(visitor: &mut V, method_type: &TypeMethod) {
+    visitor.visit_ident(method_type.span, method_type.ident);
+    visitor.visit_explicit_self(&method_type.explicit_self);
     for argument_type in method_type.decl.inputs.iter() {
-        visitor.visit_ty(&*argument_type.ty, env.clone())
+        visitor.visit_ty(&*argument_type.ty)
     }
-    visitor.visit_generics(&method_type.generics, env.clone());
-    visitor.visit_ty(&*method_type.decl.output, env.clone());
+    visitor.visit_generics(&method_type.generics);
+    visitor.visit_ty(&*method_type.decl.output);
     for attr in method_type.attrs.iter() {
-        visitor.visit_attribute(attr, env.clone());
+        visitor.visit_attribute(attr);
     }
 }
 
-pub fn walk_trait_item<E: Clone, V: Visitor<E>>(visitor: &mut V,
-                                                  trait_method: &TraitItem,
-                                                  env: E) {
+pub fn walk_trait_item<V: Visitor>(visitor: &mut V, trait_method: &TraitItem) {
     match *trait_method {
         RequiredMethod(ref method_type) => {
-            visitor.visit_ty_method(method_type, env)
+            visitor.visit_ty_method(method_type)
         }
-        ProvidedMethod(ref method) => walk_method_helper(visitor, &**method, env),
+        ProvidedMethod(ref method) => walk_method_helper(visitor, &**method),
     }
 }
 
-pub fn walk_struct_def<E: Clone, V: Visitor<E>>(visitor: &mut V,
-                                                struct_definition: &StructDef,
-                                                env: E) {
+pub fn walk_struct_def<V: Visitor>(visitor: &mut V,
+                                   struct_definition: &StructDef) {
     match struct_definition.super_struct {
-        Some(ref t) => visitor.visit_ty(&**t, env.clone()),
+        Some(ref t) => visitor.visit_ty(&**t),
         None => {},
     }
     for field in struct_definition.fields.iter() {
-        visitor.visit_struct_field(field, env.clone())
+        visitor.visit_struct_field(field)
     }
 }
 
-pub fn walk_struct_field<E: Clone, V: Visitor<E>>(visitor: &mut V,
-                                                  struct_field: &StructField,
-                                                  env: E) {
+pub fn walk_struct_field<V: Visitor>(visitor: &mut V,
+                                     struct_field: &StructField) {
     match struct_field.node.kind {
         NamedField(name, _) => {
-            visitor.visit_ident(struct_field.span, name, env.clone())
+            visitor.visit_ident(struct_field.span, name)
         }
         _ => {}
     }
 
-    visitor.visit_ty(&*struct_field.node.ty, env.clone());
+    visitor.visit_ty(&*struct_field.node.ty);
 
     for attr in struct_field.node.attrs.iter() {
-        visitor.visit_attribute(attr, env.clone());
+        visitor.visit_attribute(attr);
     }
 }
 
-pub fn walk_block<E: Clone, V: Visitor<E>>(visitor: &mut V, block: &Block, env: E) {
+pub fn walk_block<V: Visitor>(visitor: &mut V, block: &Block) {
     for view_item in block.view_items.iter() {
-        visitor.visit_view_item(view_item, env.clone())
+        visitor.visit_view_item(view_item)
     }
     for statement in block.stmts.iter() {
-        visitor.visit_stmt(&**statement, env.clone())
+        visitor.visit_stmt(&**statement)
     }
-    walk_expr_opt(visitor, block.expr, env)
+    walk_expr_opt(visitor, block.expr)
 }
 
-pub fn walk_stmt<E: Clone, V: Visitor<E>>(visitor: &mut V, statement: &Stmt, env: E) {
+pub fn walk_stmt<V: Visitor>(visitor: &mut V, statement: &Stmt) {
     match statement.node {
-        StmtDecl(ref declaration, _) => visitor.visit_decl(&**declaration, env),
+        StmtDecl(ref declaration, _) => visitor.visit_decl(&**declaration),
         StmtExpr(ref expression, _) | StmtSemi(ref expression, _) => {
-            visitor.visit_expr(&**expression, env)
+            visitor.visit_expr(&**expression)
         }
-        StmtMac(ref macro, _) => visitor.visit_mac(macro, env),
+        StmtMac(ref macro, _) => visitor.visit_mac(macro),
     }
 }
 
-pub fn walk_decl<E: Clone, V: Visitor<E>>(visitor: &mut V, declaration: &Decl, env: E) {
+pub fn walk_decl<V: Visitor>(visitor: &mut V, declaration: &Decl) {
     match declaration.node {
-        DeclLocal(ref local) => visitor.visit_local(&**local, env),
-        DeclItem(ref item) => visitor.visit_item(&**item, env),
+        DeclLocal(ref local) => visitor.visit_local(&**local),
+        DeclItem(ref item) => visitor.visit_item(&**item),
     }
 }
 
-pub fn walk_expr_opt<E: Clone, V: Visitor<E>>(visitor: &mut V,
-                                              optional_expression: Option<Gc<Expr>>,
-                                              env: E) {
+pub fn walk_expr_opt<V: Visitor>(visitor: &mut V,
+                                 optional_expression: Option<Gc<Expr>>) {
     match optional_expression {
         None => {}
-        Some(ref expression) => visitor.visit_expr(&**expression, env),
+        Some(ref expression) => visitor.visit_expr(&**expression),
     }
 }
 
-pub fn walk_exprs<E: Clone, V: Visitor<E>>(visitor: &mut V,
-                                           expressions: &[Gc<Expr>],
-                                           env: E) {
+pub fn walk_exprs<V: Visitor>(visitor: &mut V, expressions: &[Gc<Expr>]) {
     for expression in expressions.iter() {
-        visitor.visit_expr(&**expression, env.clone())
+        visitor.visit_expr(&**expression)
     }
 }
 
-pub fn walk_mac<E, V: Visitor<E>>(_: &mut V, _: &Mac, _: E) {
+pub fn walk_mac<V: Visitor>(_: &mut V, _: &Mac) {
     // Empty!
 }
 
-pub fn walk_expr<E: Clone, V: Visitor<E>>(visitor: &mut V, expression: &Expr, env: E) {
+pub fn walk_expr<V: Visitor>(visitor: &mut V, expression: &Expr) {
     match expression.node {
         ExprBox(ref place, ref subexpression) => {
-            visitor.visit_expr(&**place, env.clone());
-            visitor.visit_expr(&**subexpression, env.clone())
+            visitor.visit_expr(&**place);
+            visitor.visit_expr(&**subexpression)
         }
         ExprVec(ref subexpressions) => {
-            walk_exprs(visitor, subexpressions.as_slice(), env.clone())
+            walk_exprs(visitor, subexpressions.as_slice())
         }
         ExprRepeat(ref element, ref count) => {
-            visitor.visit_expr(&**element, env.clone());
-            visitor.visit_expr(&**count, env.clone())
+            visitor.visit_expr(&**element);
+            visitor.visit_expr(&**count)
         }
         ExprStruct(ref path, ref fields, optional_base) => {
-            visitor.visit_path(path, expression.id, env.clone());
+            visitor.visit_path(path, expression.id);
             for field in fields.iter() {
-                visitor.visit_expr(&*field.expr, env.clone())
+                visitor.visit_expr(&*field.expr)
             }
-            walk_expr_opt(visitor, optional_base, env.clone())
+            walk_expr_opt(visitor, optional_base)
         }
         ExprTup(ref subexpressions) => {
             for subexpression in subexpressions.iter() {
-                visitor.visit_expr(&**subexpression, env.clone())
+                visitor.visit_expr(&**subexpression)
             }
         }
         ExprCall(ref callee_expression, ref arguments) => {
             for argument in arguments.iter() {
-                visitor.visit_expr(&**argument, env.clone())
+                visitor.visit_expr(&**argument)
             }
-            visitor.visit_expr(&**callee_expression, env.clone())
+            visitor.visit_expr(&**callee_expression)
         }
         ExprMethodCall(_, ref types, ref arguments) => {
-            walk_exprs(visitor, arguments.as_slice(), env.clone());
+            walk_exprs(visitor, arguments.as_slice());
             for typ in types.iter() {
-                visitor.visit_ty(&**typ, env.clone())
+                visitor.visit_ty(&**typ)
             }
         }
         ExprBinary(_, ref left_expression, ref right_expression) => {
-            visitor.visit_expr(&**left_expression, env.clone());
-            visitor.visit_expr(&**right_expression, env.clone())
+            visitor.visit_expr(&**left_expression);
+            visitor.visit_expr(&**right_expression)
         }
         ExprAddrOf(_, ref subexpression) | ExprUnary(_, ref subexpression) => {
-            visitor.visit_expr(&**subexpression, env.clone())
+            visitor.visit_expr(&**subexpression)
         }
         ExprLit(_) => {}
         ExprCast(ref subexpression, ref typ) => {
-            visitor.visit_expr(&**subexpression, env.clone());
-            visitor.visit_ty(&**typ, env.clone())
+            visitor.visit_expr(&**subexpression);
+            visitor.visit_ty(&**typ)
         }
         ExprIf(ref head_expression, ref if_block, optional_else) => {
-            visitor.visit_expr(&**head_expression, env.clone());
-            visitor.visit_block(&**if_block, env.clone());
-            walk_expr_opt(visitor, optional_else, env.clone())
+            visitor.visit_expr(&**head_expression);
+            visitor.visit_block(&**if_block);
+            walk_expr_opt(visitor, optional_else)
         }
         ExprWhile(ref subexpression, ref block, _) => {
-            visitor.visit_expr(&**subexpression, env.clone());
-            visitor.visit_block(&**block, env.clone())
+            visitor.visit_expr(&**subexpression);
+            visitor.visit_block(&**block)
         }
         ExprForLoop(ref pattern, ref subexpression, ref block, _) => {
-            visitor.visit_pat(&**pattern, env.clone());
-            visitor.visit_expr(&**subexpression, env.clone());
-            visitor.visit_block(&**block, env.clone())
+            visitor.visit_pat(&**pattern);
+            visitor.visit_expr(&**subexpression);
+            visitor.visit_block(&**block)
         }
-        ExprLoop(ref block, _) => visitor.visit_block(&**block, env.clone()),
+        ExprLoop(ref block, _) => visitor.visit_block(&**block),
         ExprMatch(ref subexpression, ref arms) => {
-            visitor.visit_expr(&**subexpression, env.clone());
+            visitor.visit_expr(&**subexpression);
             for arm in arms.iter() {
-                visitor.visit_arm(arm, env.clone())
+                visitor.visit_arm(arm)
             }
         }
         ExprFnBlock(_, ref function_declaration, ref body) => {
@@ -796,81 +755,78 @@ pub fn walk_expr<E: Clone, V: Visitor<E>>(visitor: &mut V, expression: &Expr, en
                              &**function_declaration,
                              &**body,
                              expression.span,
-                             expression.id,
-                             env.clone())
+                             expression.id)
         }
         ExprUnboxedFn(_, _, ref function_declaration, ref body) => {
             visitor.visit_fn(&FkFnBlock,
                              &**function_declaration,
                              &**body,
                              expression.span,
-                             expression.id,
-                             env.clone())
+                             expression.id)
         }
         ExprProc(ref function_declaration, ref body) => {
             visitor.visit_fn(&FkFnBlock,
                              &**function_declaration,
                              &**body,
                              expression.span,
-                             expression.id,
-                             env.clone())
+                             expression.id)
         }
-        ExprBlock(ref block) => visitor.visit_block(&**block, env.clone()),
+        ExprBlock(ref block) => visitor.visit_block(&**block),
         ExprAssign(ref left_hand_expression, ref right_hand_expression) => {
-            visitor.visit_expr(&**right_hand_expression, env.clone());
-            visitor.visit_expr(&**left_hand_expression, env.clone())
+            visitor.visit_expr(&**right_hand_expression);
+            visitor.visit_expr(&**left_hand_expression)
         }
         ExprAssignOp(_, ref left_expression, ref right_expression) => {
-            visitor.visit_expr(&**right_expression, env.clone());
-            visitor.visit_expr(&**left_expression, env.clone())
+            visitor.visit_expr(&**right_expression);
+            visitor.visit_expr(&**left_expression)
         }
         ExprField(ref subexpression, _, ref types) => {
-            visitor.visit_expr(&**subexpression, env.clone());
+            visitor.visit_expr(&**subexpression);
             for typ in types.iter() {
-                visitor.visit_ty(&**typ, env.clone())
+                visitor.visit_ty(&**typ)
             }
         }
         ExprTupField(ref subexpression, _, ref types) => {
-            visitor.visit_expr(&**subexpression, env.clone());
+            visitor.visit_expr(&**subexpression);
             for typ in types.iter() {
-                visitor.visit_ty(&**typ, env.clone())
+                visitor.visit_ty(&**typ)
             }
         }
         ExprIndex(ref main_expression, ref index_expression) => {
-            visitor.visit_expr(&**main_expression, env.clone());
-            visitor.visit_expr(&**index_expression, env.clone())
+            visitor.visit_expr(&**main_expression);
+            visitor.visit_expr(&**index_expression)
         }
         ExprPath(ref path) => {
-            visitor.visit_path(path, expression.id, env.clone())
+            visitor.visit_path(path, expression.id)
         }
         ExprBreak(_) | ExprAgain(_) => {}
         ExprRet(optional_expression) => {
-            walk_expr_opt(visitor, optional_expression, env.clone())
+            walk_expr_opt(visitor, optional_expression)
         }
-        ExprMac(ref macro) => visitor.visit_mac(macro, env.clone()),
+        ExprMac(ref macro) => visitor.visit_mac(macro),
         ExprParen(ref subexpression) => {
-            visitor.visit_expr(&**subexpression, env.clone())
+            visitor.visit_expr(&**subexpression)
         }
         ExprInlineAsm(ref ia) => {
             for &(_, ref input) in ia.inputs.iter() {
-                visitor.visit_expr(&**input, env.clone())
+                visitor.visit_expr(&**input)
             }
             for &(_, ref output, _) in ia.outputs.iter() {
-                visitor.visit_expr(&**output, env.clone())
+                visitor.visit_expr(&**output)
             }
         }
     }
 
-    visitor.visit_expr_post(expression, env.clone())
+    visitor.visit_expr_post(expression)
 }
 
-pub fn walk_arm<E: Clone, V: Visitor<E>>(visitor: &mut V, arm: &Arm, env: E) {
+pub fn walk_arm<V: Visitor>(visitor: &mut V, arm: &Arm) {
     for pattern in arm.pats.iter() {
-        visitor.visit_pat(&**pattern, env.clone())
+        visitor.visit_pat(&**pattern)
     }
-    walk_expr_opt(visitor, arm.guard, env.clone());
-    visitor.visit_expr(&*arm.body, env.clone());
+    walk_expr_opt(visitor, arm.guard);
+    visitor.visit_expr(&*arm.body);
     for attr in arm.attrs.iter() {
-        visitor.visit_attribute(attr, env.clone());
+        visitor.visit_attribute(attr);
     }
 }