rm obsolete for support from the compiler

Author: thestinger

src/librustc/middle/cfg/construct.rs

@@ -396,7 +396,6 @@ impl CFGBuilder {
             }
 
             ast::expr_addr_of(_, e) |
-            ast::expr_loop_body(e) |
             ast::expr_do_body(e) |
             ast::expr_cast(e, _) |
             ast::expr_unary(_, _, e) |

src/librustc/middle/check_loop.rs

@@ -45,14 +45,6 @@ pub fn check_crate(tcx: ty::ctxt, crate: &Crate) {
                                          can_ret: false
                                       }, v));
               }
-              expr_loop_body(@expr {node: expr_fn_block(_, ref b), _}) => {
-                let sigil = ty::ty_closure_sigil(ty::expr_ty(tcx, e));
-                let blk = (sigil == BorrowedSigil);
-                (v.visit_block)(b, (Context {
-                                         in_loop: true,
-                                         can_ret: blk
-                                     }, v));
-              }
               expr_break(_) => {
                 if !cx.in_loop {
                     tcx.sess.span_err(e.span, "`break` outside of loop");

src/librustc/middle/dataflow.rs

@@ -82,19 +82,8 @@ struct PropagationContext<'self, O> {
     changed: bool
 }
 
-#[deriving(Eq)]
-enum LoopKind {
-    /// A `while` or `loop` loop
-    TrueLoop,
-
-    /// A `for` "loop" (i.e., really a func call where `break`, `return`,
-    /// and `loop` all essentially perform an early return from the closure)
-    ForLoop
-}
-
 struct LoopScope<'self> {
     loop_id: ast::NodeId,
-    loop_kind: LoopKind,
     break_bits: ~[uint]
 }
 
@@ -509,7 +498,6 @@ impl<'self, O:DataFlowOperator> PropagationContext<'self, O> {
 
                     loop_scopes.push(LoopScope {
                         loop_id: expr.id,
-                        loop_kind: ForLoop,
                         break_bits: reslice(in_out).to_owned()
                     });
                     for input in decl.inputs.iter() {
@@ -574,7 +562,6 @@ impl<'self, O:DataFlowOperator> PropagationContext<'self, O> {
                 let mut body_bits = reslice(in_out).to_owned();
                 loop_scopes.push(LoopScope {
                     loop_id: expr.id,
-                    loop_kind: TrueLoop,
                     break_bits: reslice(in_out).to_owned()
                 });
                 self.walk_block(blk, body_bits, loop_scopes);
@@ -599,7 +586,6 @@ impl<'self, O:DataFlowOperator> PropagationContext<'self, O> {
                 self.reset(in_out);
                 loop_scopes.push(LoopScope {
                     loop_id: expr.id,
-                    loop_kind: TrueLoop,
                     break_bits: reslice(in_out).to_owned()
                 });
                 self.walk_block(blk, body_bits, loop_scopes);
@@ -646,20 +632,6 @@ impl<'self, O:DataFlowOperator> PropagationContext<'self, O> {
 
             ast::expr_ret(o_e) => {
                 self.walk_opt_expr(o_e, in_out, loop_scopes);
-
-                // is this a return from a `for`-loop closure?
-                match loop_scopes.iter().position(|s| s.loop_kind == ForLoop) {
-                    Some(i) => {
-                        // if so, add the in_out bits to the state
-                        // upon exit. Remember that we cannot count
-                        // upon the `for` loop function not to invoke
-                        // the closure again etc.
-                        self.break_from_to(expr, &mut loop_scopes[i], in_out);
-                    }
-
-                    None => {}
-                }
-
                 self.reset(in_out);
             }
 
@@ -671,22 +643,8 @@ impl<'self, O:DataFlowOperator> PropagationContext<'self, O> {
 
             ast::expr_again(label) => {
                 let scope = self.find_scope(expr, label, loop_scopes);
-
-                match scope.loop_kind {
-                    TrueLoop => {
-                        self.pop_scopes(expr, scope, in_out);
-                        self.add_to_entry_set(scope.loop_id, reslice(in_out));
-                    }
-
-                    ForLoop => {
-                        // If this `loop` construct is looping back to a `for`
-                        // loop, then `loop` is really just a return from the
-                        // closure. Therefore, we treat it the same as `break`.
-                        // See case for `expr_fn_block` for more details.
-                        self.break_from_to(expr, scope, in_out);
-                    }
-                }
-
+                self.pop_scopes(expr, scope, in_out);
+                self.add_to_entry_set(scope.loop_id, reslice(in_out));
                 self.reset(in_out);
             }
 
@@ -756,7 +714,6 @@ impl<'self, O:DataFlowOperator> PropagationContext<'self, O> {
             }
 
             ast::expr_addr_of(_, e) |
-            ast::expr_loop_body(e) |
             ast::expr_do_body(e) |
             ast::expr_cast(e, _) |
             ast::expr_unary(_, _, e) |

src/librustc/middle/liveness.rs

@@ -512,7 +512,7 @@ fn visit_expr(expr: @expr, (this, vt): (@mut IrMaps, vt<@mut IrMaps>)) {
       // otherwise, live nodes are not required:
       expr_index(*) | expr_field(*) | expr_vstore(*) | expr_vec(*) |
       expr_call(*) | expr_method_call(*) | expr_tup(*) | expr_log(*) |
-      expr_binary(*) | expr_addr_of(*) | expr_loop_body(*) |
+      expr_binary(*) | expr_addr_of(*) |
       expr_do_body(*) | expr_cast(*) | expr_unary(*) | expr_break(_) |
       expr_again(_) | expr_lit(_) | expr_ret(*) | expr_block(*) |
       expr_assign(*) | expr_assign_op(*) | expr_mac(*) |
@@ -1209,7 +1209,6 @@ impl Liveness {
           }
 
           expr_addr_of(_, e) |
-          expr_loop_body(e) |
           expr_do_body(e) |
           expr_cast(e, _) |
           expr_unary(_, _, e) |
@@ -1483,7 +1482,7 @@ fn check_expr(expr: @expr, (this, vt): (@Liveness, vt<@Liveness>)) {
       expr_call(*) | expr_method_call(*) | expr_if(*) | expr_match(*) |
       expr_while(*) | expr_loop(*) | expr_index(*) | expr_field(*) |
       expr_vstore(*) | expr_vec(*) | expr_tup(*) | expr_log(*) |
-      expr_binary(*) | expr_loop_body(*) | expr_do_body(*) |
+      expr_binary(*) | expr_do_body(*) |
       expr_cast(*) | expr_unary(*) | expr_ret(*) | expr_break(*) |
       expr_again(*) | expr_lit(_) | expr_block(*) |
       expr_mac(*) | expr_addr_of(*) | expr_struct(*) | expr_repeat(*) |

src/librustc/middle/mem_categorization.rs

@@ -423,7 +423,7 @@ impl mem_categorization_ctxt {
 
           ast::expr_addr_of(*) | ast::expr_call(*) |
           ast::expr_assign(*) | ast::expr_assign_op(*) |
-          ast::expr_fn_block(*) | ast::expr_ret(*) | ast::expr_loop_body(*) |
+          ast::expr_fn_block(*) | ast::expr_ret(*) |
           ast::expr_do_body(*) | ast::expr_unary(*) |
           ast::expr_method_call(*) | ast::expr_cast(*) | ast::expr_vstore(*) |
           ast::expr_vec(*) | ast::expr_tup(*) | ast::expr_if(*) |

src/librustc/middle/moves.rs

@@ -541,7 +541,6 @@ impl VisitContext {
                 self.consume_expr(count, visitor);
             }
 
-            expr_loop_body(base) |
             expr_do_body(base) => {
                 self.use_expr(base, comp_mode, visitor);
             }

src/librustc/middle/trans/asm.rs

@@ -41,7 +41,6 @@ pub fn trans_inline_asm(bcx: @mut Block, ia: &ast::inline_asm) -> @mut Block {
                                    ty::ByCopy,
                                    out,
                                    &mut cleanups,
-                                   None,
                                    callee::DontAutorefArg)
         }));
 
@@ -56,7 +55,6 @@ pub fn trans_inline_asm(bcx: @mut Block, ia: &ast::inline_asm) -> @mut Block {
                                    ty::ByCopy,
                                    e,
                                    &mut cleanups,
-                                   None,
                                    callee::DontAutorefArg)
         })
 
@@ -77,7 +75,6 @@ pub fn trans_inline_asm(bcx: @mut Block, ia: &ast::inline_asm) -> @mut Block {
                                    ty::ByCopy,
                                    input,
                                    &mut cleanups,
-                                   None,
                                    callee::DontAutorefArg)
         })
 

src/librustc/middle/trans/callee.rs

@@ -27,7 +27,6 @@ use middle::trans::base;
 use middle::trans::base::*;
 use middle::trans::build::*;
 use middle::trans::callee;
-use middle::trans::closure;
 use middle::trans::common;
 use middle::trans::common::*;
 use middle::trans::datum::*;
@@ -556,29 +555,9 @@ pub fn trans_call_inner(in_cx: @mut Block,
                         autoref_arg: AutorefArg)
                         -> Result {
     do base::with_scope_result(in_cx, call_info, "call") |cx| {
-        let ret_in_loop = match args {
-          ArgExprs(args) => {
-            args.len() > 0u && match args.last().node {
-              ast::expr_loop_body(@ast::expr {
-                node: ast::expr_fn_block(_, ref body),
-                _
-              }) =>  body_contains_ret(body),
-              _ => false
-            }
-          }
-          _ => false
-        };
-
         let callee = get_callee(cx);
         let mut bcx = callee.bcx;
         let ccx = cx.ccx();
-        let ret_flag = if ret_in_loop {
-            let flag = alloca(bcx, Type::bool(), "__ret_flag");
-            Store(bcx, C_bool(false), flag);
-            Some(flag)
-        } else {
-            None
-        };
 
         let (llfn, llenv) = unsafe {
             match callee.data {
@@ -611,9 +590,7 @@ pub fn trans_call_inner(in_cx: @mut Block,
         }
 
         llargs.push(llenv);
-        bcx = trans_args(bcx, args, fn_expr_ty,
-                         ret_flag, autoref_arg, &mut llargs);
-
+        bcx = trans_args(bcx, args, fn_expr_ty, autoref_arg, &mut llargs);
 
         // Now that the arguments have finished evaluating, we need to revoke
         // the cleanup for the self argument
@@ -667,20 +644,6 @@ pub fn trans_call_inner(in_cx: @mut Block,
 
         if ty::type_is_bot(ret_ty) {
             Unreachable(bcx);
-        } else if ret_in_loop {
-            let ret_flag_result = bool_to_i1(bcx, Load(bcx, ret_flag.get()));
-            bcx = do with_cond(bcx, ret_flag_result) |bcx| {
-                {
-                    let r = bcx.fcx.loop_ret;
-                    for &(flagptr, _) in r.iter() {
-                        Store(bcx, C_bool(true), flagptr);
-                        Store(bcx, C_bool(false), bcx.fcx.llretptr.get());
-                    }
-                }
-                base::cleanup_and_leave(bcx, None, Some(bcx.fcx.get_llreturn()));
-                Unreachable(bcx);
-                bcx
-            }
         }
         rslt(bcx, llresult)
     }
@@ -713,7 +676,6 @@ pub fn trans_ret_slot(bcx: @mut Block, fn_ty: ty::t, dest: Option<expr::Dest>)
 pub fn trans_args(cx: @mut Block,
                   args: CallArgs,
                   fn_ty: ty::t,
-                  ret_flag: Option<ValueRef>,
                   autoref_arg: AutorefArg,
                   llargs: &mut ~[ValueRef]) -> @mut Block
 {
@@ -728,15 +690,13 @@ pub fn trans_args(cx: @mut Block,
     // to cast her view of the arguments to the caller's view.
     match args {
       ArgExprs(arg_exprs) => {
-        let last = arg_exprs.len() - 1u;
         for (i, arg_expr) in arg_exprs.iter().enumerate() {
             let arg_val = unpack_result!(bcx, {
                 trans_arg_expr(bcx,
                                arg_tys[i],
                                ty::ByCopy,
                                *arg_expr,
                                &mut temp_cleanups,
-                               if i == last { ret_flag } else { None },
                                autoref_arg)
             });
             llargs.push(arg_val);
@@ -769,49 +729,17 @@ pub fn trans_arg_expr(bcx: @mut Block,
                       self_mode: ty::SelfMode,
                       arg_expr: @ast::expr,
                       temp_cleanups: &mut ~[ValueRef],
-                      ret_flag: Option<ValueRef>,
                       autoref_arg: AutorefArg) -> Result {
     let _icx = push_ctxt("trans_arg_expr");
     let ccx = bcx.ccx();
 
-    debug!("trans_arg_expr(formal_arg_ty=(%s), self_mode=%?, arg_expr=%s, \
-            ret_flag=%?)",
+    debug!("trans_arg_expr(formal_arg_ty=(%s), self_mode=%?, arg_expr=%s)",
            formal_arg_ty.repr(bcx.tcx()),
            self_mode,
-           arg_expr.repr(bcx.tcx()),
-           ret_flag.map(|v| bcx.val_to_str(*v)));
+           arg_expr.repr(bcx.tcx()));
 
     // translate the arg expr to a datum
-    let arg_datumblock = match ret_flag {
-        None => expr::trans_to_datum(bcx, arg_expr),
-
-        // If there is a ret_flag, this *must* be a loop body
-        Some(_) => {
-            match arg_expr.node {
-                ast::expr_loop_body(
-                    blk @ @ast::expr {
-                        node: ast::expr_fn_block(ref decl, ref body),
-                        _
-                    }) => {
-                    let scratch_ty = expr_ty(bcx, arg_expr);
-                    let scratch = alloc_ty(bcx, scratch_ty, "__ret_flag");
-                    let arg_ty = expr_ty(bcx, arg_expr);
-                    let sigil = ty::ty_closure_sigil(arg_ty);
-                    let bcx = closure::trans_expr_fn(
-                        bcx, sigil, decl, body, arg_expr.id,
-                        blk.id, Some(ret_flag), expr::SaveIn(scratch));
-                    DatumBlock {bcx: bcx,
-                                datum: Datum {val: scratch,
-                                              ty: scratch_ty,
-                                              mode: ByRef(RevokeClean)}}
-                }
-                _ => {
-                    bcx.sess().impossible_case(
-                        arg_expr.span, "ret_flag with non-loop-body expr");
-                }
-            }
-        }
-    };
+    let arg_datumblock = expr::trans_to_datum(bcx, arg_expr);
     let arg_datum = arg_datumblock.datum;
     let bcx = arg_datumblock.bcx;
 

src/librustc/middle/trans/expr.rs

@@ -605,27 +605,6 @@ fn trans_rvalue_dps_unadjusted(bcx: @mut Block, expr: @ast::expr,
                                           expr.id, expr.id,
                                           None, dest);
         }
-        ast::expr_loop_body(blk) => {
-            let expr_ty = expr_ty(bcx, expr);
-            let sigil = ty::ty_closure_sigil(expr_ty);
-            match blk.node {
-                ast::expr_fn_block(ref decl, ref body) => {
-                    return closure::trans_expr_fn(bcx,
-                                                  sigil,
-                                                  decl,
-                                                  body,
-                                                  expr.id,
-                                                  blk.id,
-                                                  Some(None),
-                                                  dest);
-                }
-                _ => {
-                    bcx.sess().impossible_case(
-                        expr.span,
-                        "loop_body has the wrong kind of contents")
-                }
-            }
-        }
         ast::expr_do_body(blk) => {
             return trans_into(bcx, blk, dest);
         }

src/librustc/middle/trans/meth.rs

@@ -137,7 +137,6 @@ pub fn trans_self_arg(bcx: @mut Block,
                    mentry.self_mode,
                    base,
                    temp_cleanups,
-                   None,
                    DontAutorefArg)
 }