---

yaml
---
r: 63743
b: refs/heads/snap-stage3
c: e8151de
h: refs/heads/master
i:
  63741: 713bc9a
  63739: 69c33fb
  63735: 3df4832
  63727: 174f1d6
  63711: 227233e
  63679: abb0550
  63615: d6ba531
  63487: 70fb7a9
v: v3

Author: brson

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 36d7f601d8d419ace8fdf14b2014a9cbf6245896
+refs/heads/snap-stage3: e8151de88ff7186d2eaf9b55be087343c148451d
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/Makefile.in

@@ -139,7 +139,7 @@ endif
 
 # version-string calculation
 CFG_GIT_DIR := $(CFG_SRC_DIR).git
-CFG_RELEASE = 0.6
+CFG_RELEASE = 0.7-pre
 CFG_VERSION = $(CFG_RELEASE)
 
 ifneq ($(wildcard $(CFG_GIT)),)

branches/snap-stage3/src/libextra/io_util.rs

@@ -10,7 +10,6 @@
 
 use core::io::{Reader, BytesReader};
 use core::io;
-use core::cast;
 
 /// An implementation of the io::Reader interface which reads a buffer of bytes
 pub struct BufReader {
@@ -30,13 +29,10 @@ impl BufReader {
     }
 
     fn as_bytes_reader<A>(&self, f: &fn(&BytesReader) -> A) -> A {
-        // XXX FIXME(#5723)
-        let bytes = ::core::util::id::<&[u8]>(self.buf);
-        let bytes: &'static [u8] = unsafe { cast::transmute(bytes) };
         // Recreating the BytesReader state every call since
         // I can't get the borrowing to work correctly
         let bytes_reader = BytesReader {
-            bytes: bytes,
+            bytes: ::core::util::id::<&[u8]>(self.buf),
             pos: @mut *self.pos
         };
 

branches/snap-stage3/src/libextra/test.rs

@@ -423,7 +423,7 @@ type MonitorMsg = (TestDesc, TestResult);
 
 fn run_tests(opts: &TestOpts,
              tests: ~[TestDescAndFn],
-             callback: &fn(e: TestEvent)) {
+             callback: @fn(e: TestEvent)) {
 
     let filtered_tests = filter_tests(opts, tests);
     let filtered_descs = filtered_tests.map(|t| copy t.desc);

branches/snap-stage3/src/librustc/metadata/csearch.rs

@@ -24,6 +24,11 @@ use syntax::ast;
 use syntax::ast_map;
 use syntax::diagnostic::expect;
 
+pub struct ProvidedTraitMethodInfo {
+    ty: ty::Method,
+    def_id: ast::def_id
+}
+
 pub struct StaticMethodInfo {
     ident: ast::ident,
     def_id: ast::def_id,
@@ -129,7 +134,7 @@ pub fn get_trait_method_def_ids(cstore: @mut cstore::CStore,
 
 pub fn get_provided_trait_methods(tcx: ty::ctxt,
                                   def: ast::def_id)
-                               -> ~[@ty::Method] {
+                               -> ~[ProvidedTraitMethodInfo] {
     let cstore = tcx.cstore;
     let cdata = cstore::get_crate_data(cstore, def.crate);
     decoder::get_provided_trait_methods(cstore.intr, cdata, def.node, tcx)

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

@@ -14,7 +14,7 @@ use core::prelude::*;
 
 use metadata::cstore::crate_metadata;
 use metadata::common::*;
-use metadata::csearch::StaticMethodInfo;
+use metadata::csearch::{ProvidedTraitMethodInfo, StaticMethodInfo};
 use metadata::csearch;
 use metadata::cstore;
 use metadata::decoder;
@@ -752,7 +752,7 @@ pub fn get_trait_method_def_ids(cdata: cmd,
 
 pub fn get_provided_trait_methods(intr: @ident_interner, cdata: cmd,
                                   id: ast::node_id, tcx: ty::ctxt) ->
-        ~[@ty::Method] {
+        ~[ProvidedTraitMethodInfo] {
     let data = cdata.data;
     let item = lookup_item(id, data);
     let mut result = ~[];
@@ -763,8 +763,13 @@ pub fn get_provided_trait_methods(intr: @ident_interner, cdata: cmd,
 
         if item_method_sort(mth) != 'p' { loop; }
 
-        vec::push(&mut result,
-                  @get_method(intr, cdata, did.node, tcx));
+        let ty_method = get_method(intr, cdata, did.node, tcx);
+        let provided_trait_method_info = ProvidedTraitMethodInfo {
+            ty: ty_method,
+            def_id: did
+        };
+
+        vec::push(&mut result, provided_trait_method_info);
     }
 
     return result;

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

@@ -959,7 +959,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
         encode_attributes(ebml_w, item.attrs);
         match ty.node {
             ast::ty_path(path, bounds, _) if path.idents.len() == 1 => {
-                assert!(bounds.is_none());
+                assert!(bounds.is_empty());
                 encode_impl_type_basename(ecx, ebml_w,
                                           ast_util::path_to_ident(path));
             }

branches/snap-stage3/src/librustc/middle/kind.rs

@@ -128,7 +128,7 @@ fn check_item(item: @item, (cx, visitor): (Context, visit::vt<Context>)) {
                             // Yes, it's a destructor.
                             match self_type.node {
                                 ty_path(_, bounds, path_node_id) => {
-                                    assert!(bounds.is_none());
+                                    assert!(bounds.is_empty());
                                     let struct_def = cx.tcx.def_map.get_copy(
                                         &path_node_id);
                                     let struct_did =
@@ -169,6 +169,10 @@ fn with_appropriate_checker(cx: Context, id: node_id,
         let id = ast_util::def_id_of_def(fv.def).node;
         let var_t = ty::node_id_to_type(cx.tcx, id);
 
+        // FIXME(#3569): Once closure capabilities are restricted based on their
+        // incoming bounds, make this check conditional based on the bounds.
+        if !check_owned(cx, var_t, fv.span) { return; }
+
         // check that only immutable variables are implicitly copied in
         check_imm_free_var(cx, fv.def, fv.span);
 
@@ -180,6 +184,10 @@ fn with_appropriate_checker(cx: Context, id: node_id,
         let id = ast_util::def_id_of_def(fv.def).node;
         let var_t = ty::node_id_to_type(cx.tcx, id);
 
+        // FIXME(#3569): Once closure capabilities are restricted based on their
+        // incoming bounds, make this check conditional based on the bounds.
+        if !check_durable(cx.tcx, var_t, fv.span) { return; }
+
         // check that only immutable variables are implicitly copied in
         check_imm_free_var(cx, fv.def, fv.span);
 
@@ -285,9 +293,9 @@ pub fn check_expr(e: @expr, (cx, v): (Context, visit::vt<Context>)) {
         expr_cast(source, _) => {
             check_cast_for_escaping_regions(cx, source, e);
             match ty::get(ty::expr_ty(cx.tcx, e)).sty {
-                ty::ty_trait(_, _, _, _, bounds) => {
+                ty::ty_trait(_, _, store, _, bounds) => {
                     let source_ty = ty::expr_ty(cx.tcx, source);
-                    check_trait_cast_bounds(cx, e.span, source_ty, bounds)
+                    check_trait_cast_bounds(cx, e.span, source_ty, bounds, store)
                 }
                 _ => { }
             }
@@ -383,14 +391,19 @@ pub fn check_freevar_bounds(cx: Context, sp: span, ty: ty::t,
 }
 
 pub fn check_trait_cast_bounds(cx: Context, sp: span, ty: ty::t,
-                               bounds: ty::BuiltinBounds) {
+                               bounds: ty::BuiltinBounds, store: ty::TraitStore) {
     do check_builtin_bounds(cx, ty, bounds) |missing| {
         cx.tcx.sess.span_err(sp,
             fmt!("cannot pack type `%s`, which does not fulfill \
                   `%s`, as a trait bounded by %s",
                  ty_to_str(cx.tcx, ty), missing.user_string(cx.tcx),
                  bounds.user_string(cx.tcx)));
     }
+    // FIXME(#3569): Remove this check when the corresponding restriction
+    // is made with type contents.
+    if store == ty::UniqTraitStore && !ty::type_is_owned(cx.tcx, ty) {
+        cx.tcx.sess.span_err(sp, "uniquely-owned trait objects must be sendable");
+    }
 }
 
 fn is_nullary_variant(cx: Context, ex: @expr) -> bool {

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

@@ -4195,19 +4195,15 @@ impl Resolver {
                     }
                 }
 
-                do bounds.map |bound_vec| {
-                    for bound_vec.iter().advance |bound| {
-                        self.resolve_type_parameter_bound(bound, visitor);
-                    }
-                };
+                for bounds.iter().advance |bound| {
+                    self.resolve_type_parameter_bound(bound, visitor);
+                }
             }
 
             ty_closure(c) => {
-                do c.bounds.map |bounds| {
-                    for bounds.iter().advance |bound| {
-                        self.resolve_type_parameter_bound(bound, visitor);
-                    }
-                };
+                for c.bounds.iter().advance |bound| {
+                    self.resolve_type_parameter_bound(bound, visitor);
+                }
                 visit_ty(ty, ((), visitor));
             }
 

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

@@ -1683,20 +1683,21 @@ pub fn copy_args_to_allocas(fcx: fn_ctxt,
 
     match fcx.llself {
       Some(slf) => {
-          let self_val = if slf.is_owned
-                  && datum::appropriate_mode(slf.t).is_by_value() {
-              let tmp = BitCast(bcx, slf.v, type_of(bcx.ccx(), slf.t));
-              let alloc = alloc_ty(bcx, slf.t);
-              Store(bcx, tmp, alloc);
-              alloc
-          } else {
-              PointerCast(bcx, slf.v, type_of(bcx.ccx(), slf.t).ptr_to())
-          };
-
-          fcx.llself = Some(ValSelfData {v: self_val, ..slf});
-          if slf.is_owned {
-              add_clean(bcx, self_val, slf.t);
-          }
+        // We really should do this regardless of whether self is owned, but
+        // it doesn't work right with default method impls yet. (FIXME: #2794)
+        if slf.is_owned {
+            let self_val = if datum::appropriate_mode(slf.t).is_by_value() {
+                let tmp = BitCast(bcx, slf.v, type_of(bcx.ccx(), slf.t));
+                let alloc = alloc_ty(bcx, slf.t);
+                Store(bcx, tmp, alloc);
+                alloc
+            } else {
+                PointerCast(bcx, slf.v, type_of(bcx.ccx(), slf.t).ptr_to())
+            };
+
+            fcx.llself = Some(ValSelfData {v: self_val, ..slf});
+            add_clean(bcx, self_val, slf.t);
+        }
       }
       _ => {}
     }
@@ -2109,7 +2110,7 @@ pub fn trans_item(ccx: @mut CrateContext, item: &ast::item) {
       }
       ast::item_impl(ref generics, _, _, ref ms) => {
         meth::trans_impl(ccx, /*bad*/copy *path, item.ident, *ms,
-                         generics, item.id);
+                         generics, None, item.id);
       }
       ast::item_mod(ref m) => {
         trans_mod(ccx, m);

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

@@ -1051,8 +1051,14 @@ pub fn trans_local_var(bcx: block, def: ast::def) -> Datum {
             debug!("def_self() reference, self_info.t=%s",
                    self_info.t.repr(bcx.tcx()));
 
+            // This cast should not be necessary. We should cast self *once*,
+            // but right now this conflicts with default methods.
+            let real_self_ty = monomorphize_type(bcx, self_info.t);
+            let llselfty = type_of::type_of(bcx.ccx(), real_self_ty).ptr_to();
+
+            let casted_val = PointerCast(bcx, self_info.v, llselfty);
             Datum {
-                val: self_info.v,
+                val: casted_val,
                 ty: self_info.t,
                 mode: ByRef(ZeroMem)
             }

branches/snap-stage3/src/librustc/middle/trans/meth.rs

@@ -49,12 +49,13 @@ pub fn trans_impl(ccx: @mut CrateContext,
                   name: ast::ident,
                   methods: &[@ast::method],
                   generics: &ast::Generics,
+                  self_ty: Option<ty::t>,
                   id: ast::node_id) {
     let _icx = push_ctxt("impl::trans_impl");
     let tcx = ccx.tcx;
 
-    debug!("trans_impl(path=%s, name=%s, id=%?)",
-           path.repr(tcx), name.repr(tcx), id);
+    debug!("trans_impl(path=%s, name=%s, self_ty=%s, id=%?)",
+           path.repr(tcx), name.repr(tcx), self_ty.repr(tcx), id);
 
     if !generics.ty_params.is_empty() { return; }
     let sub_path = vec::append_one(path, path_name(name));
@@ -64,10 +65,24 @@ pub fn trans_impl(ccx: @mut CrateContext,
             let path = vec::append_one(/*bad*/copy sub_path,
                                        path_name(method.ident));
 
+            let param_substs_opt;
+            match self_ty {
+                None => param_substs_opt = None,
+                Some(self_ty) => {
+                    param_substs_opt = Some(@param_substs {
+                        tys: ~[],
+                        vtables: None,
+                        type_param_defs: @~[],
+                        self_ty: Some(self_ty)
+                    });
+                }
+            }
+
             trans_method(ccx,
                          path,
                          *method,
-                         None,
+                         param_substs_opt,
+                         self_ty,
                          llfn,
                          ast_util::local_def(id));
         }
@@ -83,13 +98,17 @@ Translates a (possibly monomorphized) method body.
 - `method`: the AST node for the method
 - `param_substs`: if this is a generic method, the current values for
   type parameters and so forth, else none
+- `base_self_ty`: optionally, the explicit self type for this method. This
+  will be none if this is not a default method and must always be present
+  if this is a default method.
 - `llfn`: the LLVM ValueRef for the method
 - `impl_id`: the node ID of the impl this method is inside
 */
 pub fn trans_method(ccx: @mut CrateContext,
                     path: path,
                     method: &ast::method,
                     param_substs: Option<@param_substs>,
+                    base_self_ty: Option<ty::t>,
                     llfn: ValueRef,
                     impl_id: ast::def_id) {
     // figure out how self is being passed
@@ -100,14 +119,18 @@ pub fn trans_method(ccx: @mut CrateContext,
       _ => {
         // determine the (monomorphized) type that `self` maps to for
         // this method
-        let self_ty = ty::node_id_to_type(ccx.tcx, method.self_id);
+        let self_ty = match base_self_ty {
+            None => ty::node_id_to_type(ccx.tcx, method.self_id),
+            Some(provided_self_ty) => provided_self_ty,
+        };
         let self_ty = match param_substs {
             None => self_ty,
-            Some(@param_substs {tys: ref tys, self_ty: ref self_sub, _}) => {
-                ty::subst_tps(ccx.tcx, *tys, *self_sub, self_ty)
+            Some(@param_substs {tys: ref tys, _}) => {
+                ty::subst_tps(ccx.tcx, *tys, None, self_ty)
             }
         };
-        debug!("calling trans_fn with self_ty %s",
+        debug!("calling trans_fn with base_self_ty %s, self_ty %s",
+               base_self_ty.repr(ccx.tcx),
                self_ty.repr(ccx.tcx));
         match method.explicit_self.node {
           ast::sty_value => {

branches/snap-stage3/src/librustc/middle/trans/monomorphize.rs

@@ -233,14 +233,14 @@ pub fn monomorphic_fn(ccx: @mut CrateContext,
             Some(override_impl_did) => impl_did = override_impl_did
         }
 
-        meth::trans_method(ccx, pt, mth, psubsts, d, impl_did);
+        meth::trans_method(ccx, pt, mth, psubsts, None, d, impl_did);
         d
       }
       ast_map::node_trait_method(@ast::provided(mth), _, pt) => {
         let d = mk_lldecl();
         set_inline_hint_if_appr(/*bad*/copy mth.attrs, d);
         debug!("monomorphic_fn impl_did_opt is %?", impl_did_opt);
-        meth::trans_method(ccx, /*bad*/copy *pt, mth, psubsts, d,
+        meth::trans_method(ccx, /*bad*/copy *pt, mth, psubsts, None, d,
                            impl_did_opt.get());
         d
       }