---

yaml
---
r: 54237
b: refs/heads/dist-snap
c: 58338dd
h: refs/heads/master
i:
  54235: 3819db4
v: v3

Author: pcwalton

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
 refs/heads/incoming: 44d4d6de762f3f9aae1fedcf454c66b79b3ad58d
-refs/heads/dist-snap: 4de9a9440711724a88805847ab6f93336e24e157
+refs/heads/dist-snap: 58338dd3d00075301ef2d43aeb0998f53776eebe
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/RELEASES.txt

@@ -62,8 +62,6 @@ Version 0.6 (March 2013)
       * Pattern matching over vectors improved and expanded
       * Typechecking of closure types has been overhauled to
         improve inference and eliminate unsoundness
-      * Macros leave scope at the end of modules, unless that module is
-        tagged with #[macro_escape]
 
    * Libraries
       * Added big integers to `std::bigint`

branches/dist-snap/src/libcore/ops.rs

@@ -77,5 +77,5 @@ pub trait Shr<RHS,Result> {
 
 #[lang="index"]
 pub trait Index<Index,Result> {
-    fn index(&self, index: &Index) -> Result;
+    fn index(&self, index: Index) -> Result;
 }

branches/dist-snap/src/libcore/rt/context.rs

@@ -126,7 +126,7 @@ fn initialize_call_frame(regs: &mut Registers, fptr: *c_void, arg: *c_void, sp:
 type Registers = [uint, ..22];
 
 #[cfg(target_arch = "x86_64")]
-fn new_regs() -> ~Registers { ~[0, .. 22] }
+fn new_regs() -> ~Registers { ~([0, .. 22]) }
 
 #[cfg(target_arch = "x86_64")]
 fn initialize_call_frame(regs: &mut Registers, fptr: *c_void, arg: *c_void, sp: *mut uint) {

branches/dist-snap/src/librustc/metadata/decoder.rs

@@ -630,6 +630,7 @@ fn get_self_ty(item: ebml::Doc) -> ast::self_ty_ {
     let self_ty_kind = string[0];
     match self_ty_kind as char {
         's' => { return ast::sty_static; }
+        'r' => { return ast::sty_by_ref; }
         'v' => { return ast::sty_value; }
         '@' => { return ast::sty_box(get_mutability(string[1])); }
         '~' => { return ast::sty_uniq(get_mutability(string[1])); }

branches/dist-snap/src/librustc/metadata/encoder.rs

@@ -410,6 +410,9 @@ fn encode_self_type(ebml_w: writer::Encoder, self_type: ast::self_ty_) {
         sty_static => {
             ebml_w.writer.write(&[ 's' as u8 ]);
         }
+        sty_by_ref => {
+            ebml_w.writer.write(&[ 'r' as u8 ]);
+        }
         sty_value => {
             ebml_w.writer.write(&[ 'v' as u8 ]);
         }

branches/dist-snap/src/librustc/middle/astencode.rs

@@ -342,7 +342,7 @@ fn simplify_ast(ii: ast::inlined_item) -> ast::inlined_item {
 }
 
 fn decode_ast(par_doc: ebml::Doc) -> ast::inlined_item {
-    let chi_doc = par_doc.get(c::tag_tree as uint);
+    let chi_doc = par_doc[c::tag_tree as uint];
     let d = &reader::Decoder(chi_doc);
     Decodable::decode(d)
 }
@@ -1089,9 +1089,9 @@ impl ebml_decoder_decoder_helpers for reader::Decoder {
 fn decode_side_tables(xcx: @ExtendedDecodeContext,
                       ast_doc: ebml::Doc) {
     let dcx = xcx.dcx;
-    let tbl_doc = ast_doc.get(c::tag_table as uint);
+    let tbl_doc = ast_doc[c::tag_table as uint];
     for reader::docs(tbl_doc) |tag, entry_doc| {
-        let id0 = entry_doc.get(c::tag_table_id as uint).as_int();
+        let id0 = entry_doc[c::tag_table_id as uint].as_int();
         let id = xcx.tr_id(id0);
 
         debug!(">> Side table document with tag 0x%x \
@@ -1103,7 +1103,7 @@ fn decode_side_tables(xcx: @ExtendedDecodeContext,
         } else if tag == (c::tag_table_moves_map as uint) {
             dcx.maps.moves_map.insert(id);
         } else {
-            let val_doc = entry_doc.get(c::tag_table_val as uint);
+            let val_doc = entry_doc[c::tag_table_val as uint];
             let val_dsr = &reader::Decoder(val_doc);
             if tag == (c::tag_table_def as uint) {
                 let def = decode_def(xcx, val_doc);
@@ -1172,7 +1172,7 @@ fn encode_item_ast(ebml_w: writer::Encoder, item: @ast::item) {
 
 #[cfg(test)]
 fn decode_item_ast(par_doc: ebml::Doc) -> @ast::item {
-    let chi_doc = par_doc.get(c::tag_tree as uint);
+    let chi_doc = par_doc[c::tag_tree as uint];
     let d = &reader::Decoder(chi_doc);
     @Decodable::decode(d)
 }

branches/dist-snap/src/librustc/middle/borrowck/gather_loans.rs

@@ -180,6 +180,21 @@ fn req_loans_in_expr(ex: @ast::expr,
             }
         }
 
+        match self.bccx.method_map.find(&ex.id) {
+            Some(ref method_map_entry) => {
+                match (*method_map_entry).explicit_self {
+                    ast::sty_by_ref => {
+                        let rcvr_cmt = self.bccx.cat_expr(rcvr);
+                        self.guarantee_valid(rcvr_cmt, m_imm, scope_r);
+                    }
+                    _ => {} // Nothing to do.
+                }
+            }
+            None => {
+                self.tcx().sess.span_bug(ex.span, ~"no method map entry");
+            }
+        }
+
         visit::visit_expr(ex, self, vt);
       }
 

branches/dist-snap/src/librustc/middle/liveness.rs

@@ -467,6 +467,11 @@ fn visit_fn(fk: &visit::fn_kind,
     match *fk {
         fk_method(_, _, method) => {
             match method.self_ty.node {
+                sty_by_ref => {
+                    fn_maps.add_variable(Arg(method.self_id,
+                                             special_idents::self_,
+                                             by_ref));
+                }
                 sty_value | sty_region(*) | sty_box(_) | sty_uniq(_) => {
                     fn_maps.add_variable(Arg(method.self_id,
                                              special_idents::self_,

branches/dist-snap/src/librustc/middle/moves.rs

@@ -436,7 +436,7 @@ pub impl VisitContext {
 
             expr_unary(deref, base) => {       // *base
                 if !self.use_overloaded_operator(
-                    expr, base, [], visitor)
+                    expr, DontDerefArgs, base, [], visitor)
                 {
                     // Moving out of *base moves out of base.
                     self.use_expr(base, comp_mode, visitor);
@@ -450,7 +450,7 @@ pub impl VisitContext {
 
             expr_index(lhs, rhs) => {          // lhs[rhs]
                 if !self.use_overloaded_operator(
-                    expr, lhs, [rhs], visitor)
+                    expr, DontDerefArgs, lhs, [rhs], visitor)
                 {
                     self.use_expr(lhs, comp_mode, visitor);
                     self.consume_expr(rhs, visitor);
@@ -579,15 +579,15 @@ pub impl VisitContext {
 
             expr_unary(_, lhs) => {
                 if !self.use_overloaded_operator(
-                    expr, lhs, [], visitor)
+                    expr, DontDerefArgs, lhs, [], visitor)
                 {
                     self.consume_expr(lhs, visitor);
                 }
             }
 
             expr_binary(_, lhs, rhs) => {
                 if !self.use_overloaded_operator(
-                    expr, lhs, [rhs], visitor)
+                    expr, DoDerefArgs, lhs, [rhs], visitor)
                 {
                     self.consume_expr(lhs, visitor);
                     self.consume_expr(rhs, visitor);
@@ -659,6 +659,7 @@ pub impl VisitContext {
 
     fn use_overloaded_operator(&self,
                                expr: @expr,
+                               deref_args: DerefArgs,
                                receiver_expr: @expr,
                                arg_exprs: &[@expr],
                                visitor: vt<VisitContext>) -> bool
@@ -669,10 +670,21 @@ pub impl VisitContext {
 
         self.use_receiver(expr.id, expr.span, receiver_expr, visitor);
 
-        // for overloaded operatrs, we are always passing in a
-        // borrowed pointer, so it's always read mode:
-        for arg_exprs.each |arg_expr| {
-            self.use_expr(*arg_expr, Read, visitor);
+        // The deref_args stuff should eventually be converted into
+        // adjustments.  Moreover, it should eventually be applied
+        // consistently to all overloaded operators.  But that's not
+        // how it is today.
+        match deref_args {
+            DoDerefArgs => {
+                // we are always passing in a borrowed pointer,
+                // so it's always read mode:
+                for arg_exprs.each |arg_expr| {
+                    self.use_expr(*arg_expr, Read, visitor);
+                }
+            }
+            DontDerefArgs => {
+                self.use_fn_args(expr.callee_id, arg_exprs, visitor);
+            }
         }
 
         return true;
@@ -725,7 +737,20 @@ pub impl VisitContext {
                     receiver_expr: @expr,
                     visitor: vt<VisitContext>)
     {
-        self.use_fn_arg(by_copy, receiver_expr, visitor);
+        let callee_mode = match self.method_map.find(&expr_id) {
+            Some(ref method_map_entry) => {
+                match method_map_entry.explicit_self {
+                    sty_by_ref => by_ref,
+                    _ => by_copy
+                }
+            }
+            None => {
+                self.tcx.sess.span_bug(
+                    span,
+                    ~"no method map entry");
+            }
+        };
+        self.use_fn_arg(callee_mode, receiver_expr, visitor);
     }
 
     fn use_fn_args(&self,

branches/dist-snap/src/librustc/middle/resolve.rs

@@ -50,7 +50,7 @@ use syntax::ast::{named_field, ne, neg, node_id, pat, pat_enum, pat_ident};
 use syntax::ast::{path, pat_box, pat_lit, pat_range, pat_struct};
 use syntax::ast::{pat_tup, pat_uniq, pat_wild, prim_ty, private, provided};
 use syntax::ast::{public, required, rem, self_ty_, shl, shr, stmt_decl};
-use syntax::ast::{struct_dtor, struct_field, struct_variant_kind};
+use syntax::ast::{struct_dtor, struct_field, struct_variant_kind, sty_by_ref};
 use syntax::ast::{sty_static, subtract, trait_ref, tuple_variant_kind, Ty};
 use syntax::ast::{ty_bool, ty_char, ty_f, ty_f32, ty_f64, ty_float, ty_i};
 use syntax::ast::{ty_i16, ty_i32, ty_i64, ty_i8, ty_int, TyParam, ty_path};
@@ -3792,6 +3792,7 @@ pub impl Resolver {
         // we only have self ty if it is a non static method
         let self_binding = match method.self_ty.node {
           sty_static => { NoSelfBinding }
+          sty_by_ref => { HasSelfBinding(method.self_id, true) }
           _ => { HasSelfBinding(method.self_id, false) }
         };
 

branches/dist-snap/src/librustc/middle/trans/base.rs

@@ -2540,8 +2540,9 @@ pub fn get_item_val(ccx: @CrateContext, id: ast::node_id) -> ValueRef {
             }
           }
 
-          _ => {
-            ccx.sess.bug(~"get_item_val(): unexpected variant")
+          ref variant => {
+            ccx.sess.bug(fmt!("get_item_val(): unexpected variant: %?",
+                              variant))
           }
         };
         if !(exprt || ccx.reachable.contains(&id)) {
@@ -3085,6 +3086,7 @@ pub fn trans_crate(sess: session::Session,
               const_cstr_cache: @mut LinearMap::new(),
               const_globals: @mut LinearMap::new(),
               const_values: @mut LinearMap::new(),
+              extern_const_values: @mut LinearMap::new(),
               module_data: @mut LinearMap::new(),
               lltypes: @mut LinearMap::new(),
               llsizingtypes: @mut LinearMap::new(),

branches/dist-snap/src/librustc/middle/trans/common.rs

@@ -201,6 +201,10 @@ pub struct CrateContext {
 
      // Cache of emitted const values
      const_values: @mut LinearMap<ast::node_id, ValueRef>,
+
+     // Cache of external const values
+     extern_const_values: @mut LinearMap<ast::def_id, ValueRef>,
+
      module_data: @mut LinearMap<~str, ValueRef>,
      lltypes: @mut LinearMap<ty::t, TypeRef>,
      llsizingtypes: @mut LinearMap<ty::t, TypeRef>,

branches/dist-snap/src/librustc/middle/trans/expr.rs

@@ -124,6 +124,7 @@ use core::prelude::*;
 use back::abi;
 use lib;
 use lib::llvm::{ValueRef, TypeRef, llvm, True};
+use metadata::csearch;
 use middle::borrowck::root_map_key;
 use middle::trans::_match;
 use middle::trans::adt;
@@ -150,6 +151,7 @@ use middle::ty::{AutoPtr, AutoBorrowVec, AutoBorrowVecRef, AutoBorrowFn,
 use util::common::indenter;
 use util::ppaux::ty_to_str;
 
+use core::cast::transmute;
 use core::hashmap::linear::LinearMap;
 use syntax::print::pprust::{expr_to_str};
 use syntax::ast;
@@ -766,15 +768,18 @@ fn trans_rvalue_dps_unadjusted(bcx: block, expr: @ast::expr,
         }
         ast::expr_binary(_, lhs, rhs) => {
             // if not overloaded, would be RvalueDatumExpr
-            return trans_overloaded_op(bcx, expr, lhs, ~[rhs], dest);
+            return trans_overloaded_op(bcx, expr, lhs, ~[rhs], dest,
+                                       DoAutorefArg);
         }
         ast::expr_unary(_, subexpr) => {
             // if not overloaded, would be RvalueDatumExpr
-            return trans_overloaded_op(bcx, expr, subexpr, ~[], dest);
+            return trans_overloaded_op(bcx, expr, subexpr, ~[], dest,
+                                       DontAutorefArg);
         }
         ast::expr_index(base, idx) => {
             // if not overloaded, would be RvalueDatumExpr
-            return trans_overloaded_op(bcx, expr, base, ~[idx], dest);
+            return trans_overloaded_op(bcx, expr, base, ~[idx], dest,
+                                       DontAutorefArg);
         }
         ast::expr_cast(val, _) => {
             match ty::get(node_id_type(bcx, expr.id)).sty {
@@ -1093,11 +1098,35 @@ fn trans_lvalue_unadjusted(bcx: block, expr: @ast::expr) -> DatumBlock {
 
                 fn get_val(bcx: block, did: ast::def_id, const_ty: ty::t)
                     -> ValueRef {
-                    // The LLVM global has the type of its initializer,
-                    // which may not be equal to the enum's type for
-                    // non-C-like enums.
-                    PointerCast(bcx, base::get_item_val(bcx.ccx(), did.node),
-                                T_ptr(type_of(bcx.ccx(), const_ty)))
+                    if did.crate == ast::local_crate {
+                        // The LLVM global has the type of its initializer,
+                        // which may not be equal to the enum's type for
+                        // non-C-like enums.
+                        PointerCast(bcx,
+                                    base::get_item_val(bcx.ccx(), did.node),
+                                    T_ptr(type_of(bcx.ccx(), const_ty)))
+                    } else {
+                        // For external constants, we don't inline.
+                        match bcx.ccx().extern_const_values.find(&did) {
+                            None => {
+                                unsafe {
+                                    let llty = type_of(bcx.ccx(), const_ty);
+                                    let symbol = csearch::get_symbol(
+                                        bcx.ccx().sess.cstore,
+                                        did);
+                                    let llval = llvm::LLVMAddGlobal(
+                                        bcx.ccx().llmod,
+                                        llty,
+                                        transmute::<&u8,*i8>(&symbol[0]));
+                                    bcx.ccx().extern_const_values.insert(
+                                        did,
+                                        llval);
+                                    llval
+                                }
+                            }
+                            Some(llval) => *llval
+                        }
+                    }
                 }
 
                 let did = get_did(ccx, did);
@@ -1641,15 +1670,16 @@ fn trans_overloaded_op(bcx: block,
                        expr: @ast::expr,
                        rcvr: @ast::expr,
                        +args: ~[@ast::expr],
-                       dest: Dest) -> block
+                       dest: Dest,
+                       +autoref_arg: AutorefArg) -> block
 {
     let origin = *bcx.ccx().maps.method_map.get(&expr.id);
     let fty = node_id_type(bcx, expr.callee_id);
     return callee::trans_call_inner(
         bcx, expr.info(), fty,
         expr_ty(bcx, expr),
         |bcx| meth::trans_method_callee(bcx, expr.callee_id, rcvr, origin),
-        callee::ArgExprs(args), dest, DoAutorefArg);
+        callee::ArgExprs(args), dest, autoref_arg);
 }
 
 fn int_cast(bcx: block, lldsttype: TypeRef, llsrctype: TypeRef,
@@ -1802,7 +1832,7 @@ fn trans_assign_op(bcx: block,
         // FIXME(#2528) evaluates the receiver twice!!
         let scratch = scratch_datum(bcx, dst_datum.ty, false);
         let bcx = trans_overloaded_op(bcx, expr, dst, ~[src],
-                                      SaveIn(scratch.val));
+                                      SaveIn(scratch.val), DoAutorefArg);
         return scratch.move_to_datum(bcx, DROP_EXISTING, dst_datum);
     }