libsyntax: manually copy lambda exprs to accommodate by-val upvars.

Author: pcwalton

src/libsyntax/ext/deriving/clone.rs

@@ -54,8 +54,6 @@ fn cs_clone(
     let clone_ident = substr.method_ident;
     let ctor_ident;
     let all_fields;
-    let subcall = |field: &FieldInfo|
-        cx.expr_method_call(field.span, field.self_, clone_ident, Vec::new());
 
     match *substr.fields {
         Struct(ref af) => {
@@ -81,7 +79,15 @@ fn cs_clone(
 
     if all_fields.len() >= 1 && all_fields.get(0).name.is_none() {
         // enum-like
-        let subcalls = all_fields.iter().map(subcall).collect();
+        let subcalls = {
+            let subcall = |field: &FieldInfo| {
+                cx.expr_method_call(field.span,
+                                    field.self_,
+                                    clone_ident,
+                                    Vec::new())
+            };
+            all_fields.iter().map(subcall).collect()
+        };
         cx.expr_call_ident(trait_span, ctor_ident, subcalls)
     } else {
         // struct-like
@@ -95,6 +101,12 @@ fn cs_clone(
                                         name).as_slice())
                 }
             };
+            let subcall = |field: &FieldInfo| {
+                cx.expr_method_call(field.span,
+                                    field.self_,
+                                    clone_ident,
+                                    Vec::new())
+            };
             cx.field_imm(field.span, ident, subcall(field))
         }).collect::<Vec<_>>();
 

src/libsyntax/ext/deriving/default.rs

@@ -52,7 +52,6 @@ fn default_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructur
         cx.ident_of("Default"),
         cx.ident_of("default")
     );
-    let default_call = |span| cx.expr_call_global(span, default_ident.clone(), Vec::new());
 
     return match *substr.fields {
         StaticStruct(_, ref summary) => {
@@ -61,14 +60,35 @@ fn default_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructur
                     if fields.is_empty() {
                         cx.expr_ident(trait_span, substr.type_ident)
                     } else {
-                        let exprs = fields.iter().map(|sp| default_call(*sp)).collect();
-                        cx.expr_call_ident(trait_span, substr.type_ident, exprs)
+                        let exprs = {
+                            let default_call = |span| {
+                                cx.expr_call_global(span,
+                                                    default_ident.clone(),
+                                                    Vec::new())
+                            };
+                            fields.iter()
+                                  .map(|sp| default_call(*sp))
+                                  .collect()
+                        };
+                        cx.expr_call_ident(trait_span,
+                                           substr.type_ident,
+                                           exprs)
                     }
                 }
                 Named(ref fields) => {
-                    let default_fields = fields.iter().map(|&(ident, span)| {
-                        cx.field_imm(span, ident, default_call(span))
-                    }).collect();
+                    let default_fields = {
+                        let cx: &ExtCtxt = cx;
+                        let default_ident_ref = &default_ident;
+                        fields.iter().map(|&(ident, span)| {
+                            let default_call = |span| {
+                                cx.expr_call_global(
+                                    span,
+                                    (*default_ident_ref).clone(),
+                                    Vec::new())
+                            };
+                            cx.field_imm(span, ident, default_call(span))
+                        }).collect()
+                    };
                     cx.expr_struct_ident(trait_span, substr.type_ident, default_fields)
                 }
             }

src/libsyntax/ext/deriving/hash.rs

@@ -69,10 +69,6 @@ fn hash_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure)
         _ => cx.span_bug(trait_span, "incorrect number of arguments in `deriving(Hash)`")
     };
     let hash_ident = substr.method_ident;
-    let call_hash = |span, thing_expr| {
-        let expr = cx.expr_method_call(span, thing_expr, hash_ident, vec!(state_expr));
-        cx.stmt_expr(expr)
-    };
     let mut stmts = Vec::new();
 
     let fields = match *substr.fields {
@@ -85,6 +81,13 @@ fn hash_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure)
                 None => cx.expr_uint(trait_span, index)
             };
 
+            let call_hash = |span, thing_expr| {
+                let expr = cx.expr_method_call(span,
+                                               thing_expr,
+                                               hash_ident,
+                                               vec!(state_expr));
+                cx.stmt_expr(expr)
+            };
             stmts.push(call_hash(trait_span, discriminant));
 
             fs
@@ -93,6 +96,13 @@ fn hash_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure)
     };
 
     for &FieldInfo { self_, span, .. } in fields.iter() {
+        let call_hash = |span, thing_expr| {
+            let expr = cx.expr_method_call(span,
+                                           thing_expr,
+                                           hash_ident,
+                                           vec!(state_expr));
+            cx.stmt_expr(expr)
+        };
         stmts.push(call_hash(span, self_));
     }
 

src/libsyntax/ext/deriving/rand.rs

@@ -62,14 +62,14 @@ fn rand_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure)
         cx.ident_of("Rand"),
         cx.ident_of("rand")
     );
-    let rand_call = |cx: &mut ExtCtxt, span| {
-        cx.expr_call_global(span,
-                            rand_ident.clone(),
-                            vec!( *rng.get(0) ))
-    };
 
     return match *substr.fields {
         StaticStruct(_, ref summary) => {
+            let rand_call = |cx: &mut ExtCtxt, span| {
+                cx.expr_call_global(span,
+                                    rand_ident.clone(),
+                                    vec!( *rng.get(0) ))
+            };
             rand_thing(cx, trait_span, substr.type_ident, summary, rand_call)
         }
         StaticEnum(_, ref variants) => {
@@ -113,6 +113,13 @@ fn rand_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure)
                 let i_expr = cx.expr_uint(v_span, i);
                 let pat = cx.pat_lit(v_span, i_expr);
 
+                let rand_ident_ptr = &rand_ident;
+                let rng_ptr = &rng;
+                let rand_call = |cx: &mut ExtCtxt, span| {
+                    cx.expr_call_global(span,
+                                        (*rand_ident_ptr).clone(),
+                                        vec!( *(*rng_ptr).get(0) ))
+                };
                 let thing = rand_thing(cx, v_span, ident, summary, |cx, sp| rand_call(cx, sp));
                 cx.arm(v_span, vec!( pat ), thing)
             }).collect::<Vec<ast::Arm> >();

src/libsyntax/ext/deriving/zero.rs

@@ -69,7 +69,6 @@ fn zero_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure)
         cx.ident_of("Zero"),
         cx.ident_of("zero")
     );
-    let zero_call = |span| cx.expr_call_global(span, zero_ident.clone(), Vec::new());
 
     return match *substr.fields {
         StaticStruct(_, ref summary) => {
@@ -78,14 +77,31 @@ fn zero_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure)
                     if fields.is_empty() {
                         cx.expr_ident(trait_span, substr.type_ident)
                     } else {
-                        let exprs = fields.iter().map(|sp| zero_call(*sp)).collect();
+                        let exprs = {
+                            let zero_call = |span| {
+                                cx.expr_call_global(span,
+                                                    zero_ident.clone(),
+                                                    Vec::new())
+                            };
+                            fields.iter().map(|sp| zero_call(*sp)).collect()
+                        };
                         cx.expr_call_ident(trait_span, substr.type_ident, exprs)
                     }
                 }
                 Named(ref fields) => {
-                    let zero_fields = fields.iter().map(|&(ident, span)| {
-                        cx.field_imm(span, ident, zero_call(span))
-                    }).collect();
+                    let zero_fields = {
+                        let cx: &ExtCtxt = cx;
+                        let zero_ident_ref = &zero_ident;
+                        fields.iter().map(|&(ident, span)| {
+                            let zero_call = |span| {
+                                cx.expr_call_global(
+                                    span,
+                                    (*zero_ident_ref).clone(),
+                                    Vec::new())
+                            };
+                            cx.field_imm(span, ident, zero_call(span))
+                        }).collect()
+                    };
                     cx.expr_struct_ident(trait_span, substr.type_ident, zero_fields)
                 }
             }