---

yaml
---
r: 34938
b: refs/heads/master
c: 2093952
h: refs/heads/master
v: v3

Author: nikomatsakis

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: d5a27a0e0c6e64d1532443a6bd45b3416e7597fe
+refs/heads/master: 209395284799bb86e34cf59493c539a35f6150dd
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: eb8fd119c65c67f3b1b8268cc7341c22d39b7b61
 refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024

trunk/doc/rust.md

@@ -1951,32 +1951,48 @@ while i < 10 {
 
 ### Infinite loops
 
-A `loop` expression denotes an infinite loop:
+The keyword `loop` in Rust appears both in _loop expressions_ and in _continue expressions_.
+A loop expression denotes an infinite loop;
+see [Continue expressions](#continue-expressions) for continue expressions.
 
 ~~~~~~~~{.ebnf .gram}
-loop_expr : "loop" '{' block '}';
+loop_expr : "loop" [ ident ':' ] '{' block '}';
 ~~~~~~~~
 
+A `loop` expression may optionally have a _label_.
+If a label is present,
+then labeled `break` and `loop` expressions nested within this loop may exit out of this loop or return control to its head.
+See [Break expressions](#break-expressions).
+
 ### Break expressions
 
 ~~~~~~~~{.ebnf .gram}
-break_expr : "break" ;
+break_expr : "break" [ ident ];
 ~~~~~~~~
 
-Executing a `break` expression immediately terminates the innermost loop
-enclosing it. It is only permitted in the body of a loop.
+A `break` expression has an optional `label`.
+If the label is absent, then executing a `break` expression immediately terminates the innermost loop enclosing it.
+It is only permitted in the body of a loop.
+If the label is present, then `break foo` terminates the loop with label `foo`,
+which need not be the innermost label enclosing the `break` expression,
+but must enclose it.
 
-### Loop expressions
+### Continue expressions
 
 ~~~~~~~~{.ebnf .gram}
-loop_expr : "loop" ;
-~~~~~~~~
-
-Evaluating a `loop` expression immediately terminates the current iteration of
-the innermost loop enclosing it, returning control to the loop *head*. In the
-case of a `while` loop, the head is the conditional expression controlling the
-loop. In the case of a `for` loop, the head is the call-expression controlling
-the loop.
+continue_expr : "loop" [ ident ];
+~~~~~~~~
+
+A continue expression, written `loop`, also has an optional `label`.
+If the label is absent,
+then executing a `loop` expression immediately terminates the current iteration of the innermost loop enclosing it,
+returning control to the loop *head*.
+In the case of a `while` loop,
+the head is the conditional expression controlling the loop.
+In the case of a `for` loop, the head is the call-expression controlling the loop.
+If the label is present, then `loop foo` returns control to the head of the loop with label `foo`,
+which need not be the innermost label enclosing the `break` expression,
+but must enclose it.
 
 A `loop` expression is only permitted in the body of a loop.
 

trunk/src/libsyntax/ast_map.rs

@@ -74,7 +74,7 @@ enum ast_node {
     // Destructor for a class
     node_dtor(~[ty_param], @class_dtor, def_id, @path),
     node_block(blk),
-    node_struct_ctor(@struct_def, @item, @path),
+    node_struct_ctor(@struct_def, @item, @path)
 }
 
 type map = std::map::HashMap<node_id, ast_node>;

trunk/src/rustc/middle/trans/base.rs

@@ -42,7 +42,6 @@ use util::ppaux;
 use util::ppaux::{ty_to_str, ty_to_short_str};
 use syntax::diagnostic::expect;
 use util::common::indenter;
-use ty::DerivedMethodInfo;
 
 use build::*;
 use shape::*;
@@ -1844,7 +1843,7 @@ fn trans_item(ccx: @crate_ctxt, item: ast::item) {
         match ms_opt {
             None => {
                 deriving::trans_deriving_impl(ccx, *path, item.ident, tps,
-                                              item.id);
+                                              None, item.id);
             }
             Some(ms) => {
                 meth::trans_impl(ccx, *path, item.ident, ms, tps, None,
@@ -2080,20 +2079,6 @@ fn get_item_val(ccx: @crate_ctxt, id: ast::node_id) -> ValueRef {
     match ccx.item_vals.find(id) {
       Some(v) => v,
       None => {
-        // First, check whether we need to automatically generate a method
-        // via the deriving mechanism.
-        match ccx.tcx.automatically_derived_methods.find(local_def(id)) {
-            None => {}  // Continue.
-            Some(ref derived_method_info) => {
-                // XXX: Mark as internal if necessary.
-                let llfn = register_deriving_method(
-                    ccx, id, derived_method_info);
-                ccx.item_vals.insert(id, llfn);
-                return llfn;
-            }
-        }
-
-        // Failing that, look for an item.
         let mut exprt = false;
         let val = match ccx.tcx.items.get(id) {
           ast_map::node_item(i, pth) => {
@@ -2241,32 +2226,6 @@ fn register_method(ccx: @crate_ctxt, id: ast::node_id, pth: @ast_map::path,
     llfn
 }
 
-fn register_deriving_method(ccx: @crate_ctxt,
-                            id: ast::node_id,
-                            derived_method_info: &DerivedMethodInfo) ->
-                            ValueRef {
-    // Find the path of the item.
-    let path, span;
-    match ccx.tcx.items.get(derived_method_info.containing_impl.node) {
-        ast_map::node_item(item, found_path) => {
-            path = found_path;
-            span = item.span;
-        }
-        _ => {
-            ccx.tcx.sess.bug(~"derived method info containing impl didn't \
-                               refer to an item");
-        }
-    }
-
-    let path = vec::append(*path, ~[
-        ast_map::path_name(derived_method_info.method_info.ident)
-    ]);
-    let mty = ty::lookup_item_type(ccx.tcx, local_def(id)).ty;
-    let llfn = register_fn_full(ccx, span, path, id, mty);
-    // XXX: Inline hint.
-    llfn
-}
-
 // The constant translation pass.
 fn trans_constant(ccx: @crate_ctxt, it: @ast::item) {
     let _icx = ccx.insn_ctxt("trans_constant");

trunk/src/rustc/middle/trans/callee.rs

@@ -210,30 +210,23 @@ fn trans_fn_ref_with_vtables(
     // intrinsic, or is a default method.  In particular, if we see an
     // intrinsic that is inlined from a different crate, we want to reemit the
     // intrinsic instead of trying to call it in the other crate.
-    let must_monomorphise;
-    if type_params.len() > 0 || opt_impl_did.is_some() {
-        must_monomorphise = true;
-    } else if ccx.tcx.automatically_derived_methods.contains_key(def_id) {
-        must_monomorphise = false;
-    } else if def_id.crate == ast::local_crate {
-        let map_node = session::expect(
-            ccx.sess,
-            ccx.tcx.items.find(def_id.node),
-            || fmt!("local item should be in ast map"));
-
-        match map_node {
-            ast_map::node_foreign_item(_,
-                                       ast::foreign_abi_rust_intrinsic,
-                                       _) => {
-                must_monomorphise = true;
-            }
-            _ => {
-                must_monomorphise = false;
+    let must_monomorphise = type_params.len() > 0 ||
+        opt_impl_did.is_some() || {
+        if def_id.crate == ast::local_crate {
+            let map_node = session::expect(
+                ccx.sess,
+                ccx.tcx.items.find(def_id.node),
+                || fmt!("local item should be in ast map"));
+
+            match map_node {
+              ast_map::node_foreign_item(
+                  _, ast::foreign_abi_rust_intrinsic, _) => true,
+              _ => false
             }
+        } else {
+            false
         }
-    } else {
-        must_monomorphise = false;
-    }
+    };
 
     // Create a monomorphic verison of generic functions
     if must_monomorphise {
@@ -441,15 +434,6 @@ fn trans_call_inner(
             _ => {}
         }
 
-        // Uncomment this to debug calls.
-        /*
-        io::println(fmt!("calling: %s", bcx.val_str(llfn)));
-        for llargs.each |llarg| {
-            io::println(fmt!("arg: %s", bcx.val_str(*llarg)));
-        }
-        io::println("---");
-        */
-
         // If the block is terminated, then one or more of the args
         // has type _|_. Since that means it diverges, the code for
         // the call itself is unreachable.

trunk/src/rustc/middle/trans/deriving.rs

@@ -1,126 +1,21 @@
 // Translation of automatically-derived trait implementations. This handles
 // enums and structs only; other types cannot be automatically derived.
 
-use lib::llvm::llvm;
-use middle::trans::base::{finish_fn, get_insn_ctxt, get_item_val};
-use middle::trans::base::{new_fn_ctxt, sub_block, top_scope_block};
-use middle::trans::build::{Br, CondBr, GEPi, Load, PointerCast, Store};
-use middle::trans::build::{ValueRef};
-use middle::trans::callee;
-use middle::trans::callee::{ArgVals, Callee, DontAutorefArg, Method};
-use middle::trans::callee::{MethodData};
-use middle::trans::common;
-use middle::trans::common::{C_bool, T_ptr, block, crate_ctxt};
-use middle::trans::expr::SaveIn;
-use middle::trans::type_of::type_of;
-use middle::typeck::method_static;
-use syntax::ast;
-use syntax::ast::{def_id, ident, node_id, ty_param};
+use middle::trans::base::get_insn_ctxt;
+use middle::trans::common::crate_ctxt;
+use syntax::ast::{ident, node_id, ty_param};
 use syntax::ast_map::path;
-use syntax::ast_util;
-use syntax::ast_util::local_def;
 
 /// The main "translation" pass for automatically-derived impls. Generates
 /// code for monomorphic methods only. Other methods will be generated when
 /// they are invoked with specific type parameters; see
 /// `trans::base::lval_static_fn()` or `trans::base::monomorphic_fn()`.
 pub fn trans_deriving_impl(ccx: @crate_ctxt, _path: path, _name: ident,
-                           tps: ~[ty_param], id: node_id) {
+                           tps: ~[ty_param], _self_ty: Option<ty::t>,
+                           _id: node_id) {
     let _icx = ccx.insn_ctxt("deriving::trans_deriving_impl");
     if tps.len() > 0 { return; }
 
-    let impl_def_id = local_def(id);
-    let self_ty = ty::lookup_item_type(ccx.tcx, impl_def_id);
-    let method_dids = ccx.tcx.automatically_derived_methods_for_impl.get(
-        impl_def_id);
-
-    for method_dids.each |method_did| {
-        let llfn = get_item_val(ccx, method_did.node);
-        match ty::get(self_ty.ty).sty {
-            ty::ty_class(*) => {
-                trans_deriving_struct_method(ccx, llfn, impl_def_id,
-                                             self_ty.ty);
-            }
-            _ => {
-                ccx.tcx.sess.unimpl(~"translation of non-struct deriving \
-                                      method");
-            }
-        }
-    }
-}
-
-fn trans_deriving_struct_method(ccx: @crate_ctxt, llfn: ValueRef,
-                                impl_did: def_id, self_ty: ty::t) {
-    let _icx = ccx.insn_ctxt("trans_deriving_struct_method");
-    let fcx = new_fn_ctxt(ccx, ~[], llfn, None);
-    let top_bcx = top_scope_block(fcx, None);
-    let lltop = top_bcx.llbb;
-    let mut bcx = top_bcx;
-
-    let llselfty = type_of(ccx, self_ty);
-    let llselfval = PointerCast(bcx, fcx.llenv, T_ptr(llselfty));
-    let llotherval = llvm::LLVMGetParam(llfn, 2);
-
-    let struct_field_tys;
-    match ty::get(self_ty).sty {
-        ty::ty_class(struct_id, ref struct_substs) => {
-            struct_field_tys = ty::class_items_as_fields(
-                ccx.tcx, struct_id, struct_substs);
-        }
-        _ => {
-            ccx.tcx.sess.bug(~"passed non-struct to \
-                               trans_deriving_struct_method");
-        }
-    }
-
-    // Iterate over every element of the struct.
-    for ccx.tcx.deriving_struct_methods.get(impl_did).eachi
-            |i, derived_method_info| {
-        let target_method_def_id;
-        match *derived_method_info {
-            method_static(did) => target_method_def_id = did,
-            _ => fail ~"derived method didn't resolve to a static method"
-        }
-
-        let fn_expr_ty =
-            ty::lookup_item_type(ccx.tcx, target_method_def_id).ty;
-
-        let llselfval = GEPi(bcx, llselfval, [0, 0, i]);
-        let llotherval = GEPi(bcx, llotherval, [0, 0, i]);
-
-        // XXX: Cross-crate won't work!
-        let llfn = get_item_val(ccx, target_method_def_id.node);
-        let cb: &fn(block) -> Callee = |block| {
-            Callee {
-                bcx: block,
-                data: Method(MethodData {
-                    llfn: llfn,
-                    llself: llselfval,
-                    self_ty: struct_field_tys[i].mt.ty,
-                    self_mode: ast::by_copy
-                })
-            }
-        };
-
-        bcx = callee::trans_call_inner(bcx,
-                                       None,
-                                       fn_expr_ty,
-                                       ty::mk_bool(ccx.tcx),
-                                       cb,
-                                       ArgVals(~[llotherval]),
-                                       SaveIn(fcx.llretptr),
-                                       DontAutorefArg);
-
-        // Return immediately if the call returned false.
-        let next_block = sub_block(top_bcx, ~"next");
-        let llcond = Load(bcx, fcx.llretptr);
-        CondBr(bcx, llcond, next_block.llbb, fcx.llreturn);
-        bcx = next_block;
-    }
-
-    Store(bcx, C_bool(true), fcx.llretptr);
-    Br(bcx, fcx.llreturn);
-
-    finish_fn(fcx, lltop);
+    // XXX: Unimplemented.
 }
 

trunk/src/rustc/middle/ty.rs

@@ -200,7 +200,6 @@ export provided_trait_methods;
 export trait_supertraits;
 export AutoAdjustment;
 export AutoRef, AutoRefKind, AutoSlice, AutoPtr;
-export DerivedMethodInfo;
 
 // Data types
 
@@ -334,11 +333,6 @@ struct InstantiatedTraitRef {
     tpt: ty_param_substs_and_ty
 }
 
-struct DerivedMethodInfo {
-    method_info: @middle::resolve::MethodInfo,
-    containing_impl: ast::def_id
-}
-
 type ctxt =
     @{diag: syntax::diagnostic::span_handler,
       interner: HashMap<intern_key, t_box>,
@@ -385,17 +379,7 @@ type ctxt =
       provided_method_sources: HashMap<ast::def_id, ProvidedMethodSource>,
       supertraits: HashMap<ast::def_id, @~[InstantiatedTraitRef]>,
       deriving_struct_methods: HashMap<ast::def_id,
-                                       @~[typeck::method_origin]>,
-
-      // A mapping from the def ID of a method that was automatically derived
-      // to information about it.
-      automatically_derived_methods: HashMap<ast::def_id, DerivedMethodInfo>,
-
-      // A mapping from the def ID of an impl to the IDs of the derived
-      // methods within it.
-      automatically_derived_methods_for_impl:
-            HashMap<ast::def_id, @~[ast::def_id]>
-      };
+                                       @~[typeck::method_origin]>};
 
 enum tbox_flag {
     has_params = 1,
@@ -958,9 +942,7 @@ fn mk_ctxt(s: session::Session,
       legacy_boxed_traits: HashMap(),
       provided_method_sources: HashMap(),
       supertraits: HashMap(),
-      deriving_struct_methods: HashMap(),
-      automatically_derived_methods: HashMap(),
-      automatically_derived_methods_for_impl: HashMap()}
+      deriving_struct_methods: HashMap()}
 }