---

yaml
---
r: 33518
b: refs/heads/snap-stage3
c: d5a27a0
h: refs/heads/master
v: v3

Author: pcwalton

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 2ab614f3569f34eee2fd70862e8f35548282fb11
+refs/heads/snap-stage3: d5a27a0e0c6e64d1532443a6bd45b3416e7597fe
 refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/doc/rust.md

@@ -1951,48 +1951,32 @@ while i < 10 {
 
 ### Infinite loops
 
-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.
+A `loop` expression denotes an infinite loop:
 
 ~~~~~~~~{.ebnf .gram}
-loop_expr : "loop" [ ident ':' ] '{' block '}';
+loop_expr : "loop" '{' 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" [ ident ];
+break_expr : "break" ;
 ~~~~~~~~
 
-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.
+Executing a `break` expression immediately terminates the innermost loop
+enclosing it. It is only permitted in the body of a loop.
 
-### Continue expressions
+### Loop expressions
 
 ~~~~~~~~{.ebnf .gram}
-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.
+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.
 
 A `loop` expression is only permitted in the body of a loop.
 

branches/snap-stage3/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>;

branches/snap-stage3/src/rustc/middle/trans/base.rs

@@ -42,6 +42,7 @@ 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::*;
@@ -1843,7 +1844,7 @@ fn trans_item(ccx: @crate_ctxt, item: ast::item) {
         match ms_opt {
             None => {
                 deriving::trans_deriving_impl(ccx, *path, item.ident, tps,
-                                              None, item.id);
+                                              item.id);
             }
             Some(ms) => {
                 meth::trans_impl(ccx, *path, item.ident, ms, tps, None,
@@ -2079,6 +2080,20 @@ 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) => {
@@ -2226,6 +2241,32 @@ 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");

branches/snap-stage3/src/rustc/middle/trans/callee.rs

@@ -210,23 +210,30 @@ 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 = 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
+    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;
             }
-        } else {
-            false
         }
-    };
+    } else {
+        must_monomorphise = false;
+    }
 
     // Create a monomorphic verison of generic functions
     if must_monomorphise {
@@ -434,6 +441,15 @@ 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.

branches/snap-stage3/src/rustc/middle/trans/deriving.rs

@@ -1,21 +1,126 @@
 // Translation of automatically-derived trait implementations. This handles
 // enums and structs only; other types cannot be automatically derived.
 
-use middle::trans::base::get_insn_ctxt;
-use middle::trans::common::crate_ctxt;
-use syntax::ast::{ident, node_id, ty_param};
+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 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], _self_ty: Option<ty::t>,
-                           _id: node_id) {
+                           tps: ~[ty_param], id: node_id) {
     let _icx = ccx.insn_ctxt("deriving::trans_deriving_impl");
     if tps.len() > 0 { return; }
 
-    // XXX: Unimplemented.
+    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);
 }
 

branches/snap-stage3/src/rustc/middle/ty.rs

@@ -200,6 +200,7 @@ export provided_trait_methods;
 export trait_supertraits;
 export AutoAdjustment;
 export AutoRef, AutoRefKind, AutoSlice, AutoPtr;
+export DerivedMethodInfo;
 
 // Data types
 
@@ -333,6 +334,11 @@ 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>,
@@ -379,7 +385,17 @@ 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]>};
+                                       @~[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]>
+      };
 
 enum tbox_flag {
     has_params = 1,
@@ -942,7 +958,9 @@ fn mk_ctxt(s: session::Session,
       legacy_boxed_traits: HashMap(),
       provided_method_sources: HashMap(),
       supertraits: HashMap(),
-      deriving_struct_methods: HashMap()}
+      deriving_struct_methods: HashMap(),
+      automatically_derived_methods: HashMap(),
+      automatically_derived_methods_for_impl: HashMap()}
 }