---

yaml
---
r: 49068
b: refs/heads/snap-stage3
c: 2f1ab3a
h: refs/heads/master
v: v3

Author: erickt

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 3bbcac322669cff3abde5be937cc4ec3860f3985
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 2c17ff7dbc667a7d579b02b86d4c08a1093683fd
+refs/heads/snap-stage3: 2f1ab3a7fad9aeb871479470785250fe2e923e19
 refs/heads/try: 2a8fb58d79e685d5ca07b039badcf2ae3ef077ea
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/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/snap-stage3/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/snap-stage3/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/snap-stage3/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/snap-stage3/src/librustc/middle/moves.rs

@@ -737,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/snap-stage3/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/snap-stage3/src/librustc/middle/trans/meth.rs

@@ -596,7 +596,7 @@ pub fn trans_trait_callee(bcx: block,
 
     let llpair = match explicit_self {
         ast::sty_region(*) => Load(bcx, llpair),
-        ast::sty_static | ast::sty_value |
+        ast::sty_static | ast::sty_by_ref | ast::sty_value |
         ast::sty_box(_) | ast::sty_uniq(_) => llpair
     };
 
@@ -645,6 +645,21 @@ pub fn trans_trait_callee_from_llval(bcx: block,
         ast::sty_static => {
             bcx.tcx().sess.bug(~"shouldn't see static method here");
         }
+        ast::sty_by_ref => {
+            // We need to pass a pointer to a pointer to the payload.
+            match store {
+                ty::BoxTraitStore |
+                ty::BareTraitStore |
+                ty::UniqTraitStore => {
+                    llself = GEPi(bcx, llbox, [0u, abi::box_field_body]);
+                }
+                ty::RegionTraitStore(_) => {
+                    llself = llbox;
+                }
+            }
+
+            self_mode = ast::by_ref;
+        }
         ast::sty_value => {
             bcx.tcx().sess.bug(~"methods with by-value self should not be \
                                called on objects");

branches/snap-stage3/src/librustc/middle/typeck/check/method.rs

@@ -99,7 +99,7 @@ use core::hashmap::linear::LinearSet;
 use core::result;
 use core::uint;
 use core::vec;
-use syntax::ast::{def_id, sty_value, sty_region, sty_box};
+use syntax::ast::{def_id, sty_by_ref, sty_value, sty_region, sty_box};
 use syntax::ast::{sty_uniq, sty_static, node_id, by_copy, by_ref};
 use syntax::ast::{m_const, m_mutbl, m_imm};
 use syntax::ast;
@@ -527,7 +527,7 @@ pub impl<'self> LookupContext<'self> {
             ast::sty_region(_) => {
                 return; // inapplicable
             }
-            ast::sty_region(_) => vstore_slice(r)
+            ast::sty_by_ref | ast::sty_region(_) => vstore_slice(r)
             ast::sty_box(_) => vstore_box, // XXX NDM mutability
             ast::sty_uniq(_) => vstore_uniq
         }
@@ -741,7 +741,7 @@ pub impl<'self> LookupContext<'self> {
         // shouldn't really have to be.
         let rcvr_substs = {
             match self_decl {
-                sty_static | sty_value |
+                sty_static | sty_value | sty_by_ref |
                 sty_box(_) | sty_uniq(_) => {
                     self_substs
                 }
@@ -1327,7 +1327,7 @@ pub fn transform_self_type_for_method(tcx: ty::ctxt,
         tcx.sess.bug(~"calling transform_self_type_for_method on \
                        static method");
       }
-      sty_value => {
+      sty_by_ref | sty_value => {
         impl_ty
       }
       sty_region(_, mutability) => {

branches/snap-stage3/src/librustc/middle/typeck/check/mod.rs

@@ -1064,7 +1064,44 @@ pub fn impl_self_ty(vcx: &VtableContext,
                  -> ty_param_substs_and_ty {
     let tcx = vcx.tcx();
 
-    let (n_tps, region_param, raw_ty) = {
+    let (n_tps, region_param, raw_ty) = if did.crate == ast::local_crate {
+        let region_param = tcx.region_paramd_items.find(&did.node).
+                               map_consume(|x| *x);
+        match tcx.items.find(&did.node) {
+          Some(&ast_map::node_item(@ast::item {
+                  node: ast::item_impl(ref ts, _, st, _),
+                  _
+              }, _)) => {
+            let region_parameterization =
+                RegionParameterization::from_variance_and_generics(
+                    region_param,
+                    ts);
+            (ts.ty_params.len(),
+             region_param,
+             vcx.ccx.to_ty(&rscope::type_rscope(region_parameterization), st))
+          }
+          Some(&ast_map::node_item(@ast::item {
+                  node: ast::item_struct(_, ref ts),
+                  id: class_id,
+                  _
+              },_)) => {
+              /* If the impl is a class, the self ty is just the class ty
+                 (doing a no-op subst for the ty params; in the next step,
+                 we substitute in fresh vars for them)
+               */
+              (ts.ty_params.len(),
+               region_param,
+               ty::mk_struct(tcx, local_def(class_id),
+                      substs {
+                        self_r: rscope::bound_self_region(region_param),
+                        self_ty: None,
+                        tps: ty::ty_params_to_tys(tcx, ts)
+                      }))
+          }
+          _ => { tcx.sess.bug(~"impl_self_ty: unbound item or item that \
+               doesn't have a self_ty"); }
+        }
+    } else {
         let ity = ty::lookup_item_type(tcx, did);
         (vec::len(*ity.bounds), ity.region_param, ity.ty)
     };

branches/snap-stage3/src/libsyntax/ast.rs

@@ -1003,6 +1003,7 @@ impl to_bytes::IterBytes for ret_style {
 #[deriving(Eq)]
 pub enum self_ty_ {
     sty_static,                                // no self
+    sty_by_ref,                                // ``
     sty_value,                                 // `self`
     sty_region(Option<@Lifetime>, mutability), // `&'lt self`
     sty_box(mutability),                       // `@self`

branches/snap-stage3/src/libsyntax/ext/deriving/clone.rs

@@ -17,7 +17,7 @@ use ast::{item_enum, item_impl, item_struct, Generics};
 use ast::{m_imm, meta_item, method};
 use ast::{named_field, or, pat, pat_ident, pat_wild, public, pure_fn};
 use ast::{stmt, struct_def, struct_variant_kind};
-use ast::{sty_region, tuple_variant_kind, ty_nil, TyParam};
+use ast::{sty_by_ref, sty_region, tuple_variant_kind, ty_nil, TyParam};
 use ast::{TyParamBound, ty_path, ty_rptr, unnamed_field, variant};
 use ext::base::ext_ctxt;
 use ext::build;

branches/snap-stage3/src/libsyntax/ext/deriving/eq.rs

@@ -17,7 +17,7 @@ use ast::{item_enum, item_impl, item_struct, Generics};
 use ast::{m_imm, meta_item, method};
 use ast::{named_field, or, pat, pat_ident, pat_wild, public, pure_fn};
 use ast::{stmt, struct_def, struct_variant_kind};
-use ast::{sty_region, tuple_variant_kind, ty_nil, TyParam};
+use ast::{sty_by_ref, sty_region, tuple_variant_kind, ty_nil, TyParam};
 use ast::{TyParamBound, ty_path, ty_rptr, unnamed_field, variant};
 use ext::base::ext_ctxt;
 use ext::build;

branches/snap-stage3/src/libsyntax/ext/deriving/iter_bytes.rs

@@ -17,7 +17,7 @@ use ast::{item_enum, item_impl, item_struct, Generics};
 use ast::{m_imm, meta_item, method};
 use ast::{named_field, or, pat, pat_ident, pat_wild, public, pure_fn};
 use ast::{stmt, struct_def, struct_variant_kind};
-use ast::{sty_region, tuple_variant_kind, ty_nil, TyParam};
+use ast::{sty_by_ref, sty_region, tuple_variant_kind, ty_nil, TyParam};
 use ast::{TyParamBound, ty_path, ty_rptr, unnamed_field, variant};
 use ext::base::ext_ctxt;
 use ext::build;

branches/snap-stage3/src/libsyntax/ext/deriving/mod.rs

@@ -20,7 +20,7 @@ use ast::{item_enum, item_impl, item_struct, Generics};
 use ast::{m_imm, meta_item, method};
 use ast::{named_field, or, pat, pat_ident, pat_wild, public, pure_fn};
 use ast::{stmt, struct_def, struct_variant_kind};
-use ast::{sty_region, tuple_variant_kind, ty_nil, TyParam};
+use ast::{sty_by_ref, sty_region, tuple_variant_kind, ty_nil, TyParam};
 use ast::{TyParamBound, ty_path, ty_rptr, unnamed_field, variant};
 use ext::base::ext_ctxt;
 use ext::build;