---

yaml
---
r: 157217
b: refs/heads/master
c: a0ee7c9
h: refs/heads/master
i:
  157215: f1dbaa2
v: v3

Author: ftxqxd

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: fc3ed0c8084960ea40e95ee0505d42ede96e8158
+refs/heads/master: a0ee7c9f55b90a541db1f6f36d18562bdf5ef6bf
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: d44ea720fa9dfe062ef06d0eb49a58d4e7e92344
 refs/heads/try: 6ecdf1fa83d7cdbf44a0091132e9c6580be72275

trunk/mk/llvm.mk

@@ -38,7 +38,7 @@ endif
 # the stamp in the source dir.
 $$(LLVM_STAMP_$(1)): $(S)src/rustllvm/llvm-auto-clean-trigger
 	@$$(call E, make: cleaning llvm)
-	$(Q)$(MAKE) clean-llvm$(1)
+	$(Q)$(MAKE) clean-llvm
 	@$$(call E, make: done cleaning llvm)
 	touch $$@
 

trunk/src/doc/guide-lifetimes.md

@@ -56,7 +56,7 @@ a reference.
 fn compute_distance(p1: &Point, p2: &Point) -> f64 {
     let x_d = p1.x - p2.x;
     let y_d = p1.y - p2.y;
-    (x_d * x_d + y_d * y_d).sqrt()
+    sqrt(x_d * x_d + y_d * y_d)
 }
 ~~~
 

trunk/src/doc/reference.md

@@ -1153,7 +1153,7 @@ exposing an API making it possible for it to occur in safe code.
 
 * Data races
 * Dereferencing a null/dangling raw pointer
-* Mutating an immutable value/reference without `UnsafeCell`
+* Mutating an immutable value/reference
 * Reads of [undef](http://llvm.org/docs/LangRef.html#undefined-values)
   (uninitialized) memory
 * Breaking the [pointer aliasing
@@ -1166,14 +1166,11 @@ exposing an API making it possible for it to occur in safe code.
   * Using `std::ptr::copy_nonoverlapping_memory` (`memcpy32`/`memcpy64`
     instrinsics) on overlapping buffers
 * Invalid values in primitive types, even in private fields/locals:
-  * Dangling/null references or boxes
+  * Dangling/null pointers in non-raw pointers, or slices
   * A value other than `false` (0) or `true` (1) in a `bool`
   * A discriminant in an `enum` not included in the type definition
   * A value in a `char` which is a surrogate or above `char::MAX`
   * non-UTF-8 byte sequences in a `str`
-* Unwinding into Rust from foreign code or unwinding from Rust into foreign
-  code. Rust's failure system is not compatible with exception handling in
-  other languages. Unwinding must be caught and handled at FFI boundaries.
 
 ##### Behaviour not considered unsafe
 

trunk/src/doc/rustdoc.md

@@ -221,7 +221,7 @@ testing this code, the `fib` function will be included (so it can compile).
 
 Running tests often requires some special configuration to filter tests, find
 libraries, or try running ignored examples. The testing framework that rustdoc
-uses is built on crate `test`, which is also used when you compile crates with
+uses is build on crate `test`, which is also used when you compile crates with
 rustc's `--test` flag. Extra arguments can be passed to rustdoc's test harness
 with the `--test-args` flag.
 

trunk/src/libarena/lib.rs

@@ -208,13 +208,13 @@ impl Arena {
     }
 
     #[inline]
-    fn alloc_copy<T>(&self, op: || -> T) -> &mut T {
+    fn alloc_copy<T>(&self, op: || -> T) -> &T {
         unsafe {
             let ptr = self.alloc_copy_inner(mem::size_of::<T>(),
                                             mem::min_align_of::<T>());
             let ptr = ptr as *mut T;
             ptr::write(&mut (*ptr), op());
-            return &mut *ptr;
+            return &*ptr;
         }
     }
 
@@ -262,7 +262,7 @@ impl Arena {
     }
 
     #[inline]
-    fn alloc_noncopy<T>(&self, op: || -> T) -> &mut T {
+    fn alloc_noncopy<T>(&self, op: || -> T) -> &T {
         unsafe {
             let tydesc = get_tydesc::<T>();
             let (ty_ptr, ptr) =
@@ -279,14 +279,14 @@ impl Arena {
             // the object is there.
             *ty_ptr = bitpack_tydesc_ptr(tydesc, true);
 
-            return &mut *ptr;
+            return &*ptr;
         }
     }
 
     /// Allocates a new item in the arena, using `op` to initialize the value,
     /// and returns a reference to it.
     #[inline]
-    pub fn alloc<T>(&self, op: || -> T) -> &mut T {
+    pub fn alloc<T>(&self, op: || -> T) -> &T {
         unsafe {
             if intrinsics::needs_drop::<T>() {
                 self.alloc_noncopy(op)
@@ -458,12 +458,12 @@ impl<T> TypedArena<T> {
 
     /// Allocates an object in the `TypedArena`, returning a reference to it.
     #[inline]
-    pub fn alloc(&self, object: T) -> &mut T {
+    pub fn alloc(&self, object: T) -> &T {
         if self.ptr == self.end {
             self.grow()
         }
 
-        let ptr: &mut T = unsafe {
+        let ptr: &T = unsafe {
             let ptr: &mut T = mem::transmute(self.ptr);
             ptr::write(ptr, object);
             self.ptr.set(self.ptr.get().offset(1));

trunk/src/libcore/atomic.rs

@@ -94,7 +94,6 @@ const UINT_TRUE: uint = -1;
 #[stable]
 impl AtomicBool {
     /// Create a new `AtomicBool`
-    #[inline]
     pub fn new(v: bool) -> AtomicBool {
         let val = if v { UINT_TRUE } else { 0 };
         AtomicBool { v: UnsafeCell::new(val), nocopy: marker::NoCopy }
@@ -306,7 +305,6 @@ impl AtomicBool {
 #[stable]
 impl AtomicInt {
     /// Create a new `AtomicInt`
-    #[inline]
     pub fn new(v: int) -> AtomicInt {
         AtomicInt {v: UnsafeCell::new(v), nocopy: marker::NoCopy}
     }
@@ -428,7 +426,6 @@ impl AtomicInt {
 #[stable]
 impl AtomicUint {
     /// Create a new `AtomicUint`
-    #[inline]
     pub fn new(v: uint) -> AtomicUint {
         AtomicUint { v: UnsafeCell::new(v), nocopy: marker::NoCopy }
     }
@@ -550,7 +547,6 @@ impl AtomicUint {
 #[stable]
 impl<T> AtomicPtr<T> {
     /// Create a new `AtomicPtr`
-    #[inline]
     pub fn new(p: *mut T) -> AtomicPtr<T> {
         AtomicPtr { p: UnsafeCell::new(p as uint), nocopy: marker::NoCopy }
     }

trunk/src/libcore/num/mod.rs

@@ -1502,7 +1502,7 @@ pub trait Float: Signed + Primitive {
 
     /// Take the square root of a number.
     ///
-    /// Returns NaN if `self` is a negative number.
+    /// Returns NaN if `self` is not a non-negative number.
     fn sqrt(self) -> Self;
     /// Take the reciprocal (inverse) square root of a number, `1/sqrt(x)`.
     fn rsqrt(self) -> Self;

trunk/src/librustc/back/write.rs

@@ -226,10 +226,12 @@ fn create_target_machine(sess: &Session) -> TargetMachineRef {
         }
     };
 
-    let triple = sess.targ_cfg.target_strs.target_triple.as_slice();
-
-    let tm = unsafe {
-            triple.with_c_str(|t| {
+    unsafe {
+        sess.targ_cfg
+             .target_strs
+             .target_triple
+             .as_slice()
+             .with_c_str(|t| {
             sess.opts.cg.target_cpu.as_slice().with_c_str(|cpu| {
                 target_feature(sess).with_c_str(|features| {
                     llvm::LLVMRustCreateTargetMachine(
@@ -247,15 +249,7 @@ fn create_target_machine(sess: &Session) -> TargetMachineRef {
                 })
             })
         })
-    };
-
-    if tm.is_null() {
-        llvm_err(sess.diagnostic().handler(),
-                 format!("Could not create LLVM TargetMachine for triple: {}",
-                         triple).to_string());
-    } else {
-        return tm;
-    };
+    }
 }
 
 

trunk/src/librustc/diagnostics.rs

@@ -53,6 +53,7 @@ register_diagnostics!(
     E0035,
     E0036,
     E0038,
+    E0039,
     E0040,
     E0044,
     E0045,

trunk/src/librustc/lint/context.rs

@@ -221,8 +221,8 @@ impl LintStore {
 
         add_lint_group!(sess, "unused",
                         UNUSED_IMPORTS, UNUSED_VARIABLES, UNUSED_ASSIGNMENTS, DEAD_CODE,
-                        UNUSED_MUT, UNREACHABLE_CODE, UNUSED_EXTERN_CRATES, UNUSED_MUST_USE,
-                        UNUSED_UNSAFE, UNUSED_RESULTS, PATH_STATEMENTS)
+                        UNUSED_MUT, UNREACHABLE_CODE, UNUSED_MUST_USE,
+                        UNUSED_UNSAFE, PATH_STATEMENTS)
 
         // We have one lint pass defined in this module.
         self.register_pass(sess, false, box GatherNodeLevels as LintPassObject);

trunk/src/librustc/middle/check_static_recursion.rs

@@ -99,17 +99,7 @@ impl<'a, 'ast, 'v> Visitor<'v> for CheckItemRecursionVisitor<'a, 'ast> {
                     Some(&DefStatic(def_id, _)) |
                     Some(&DefConst(def_id)) if
                             ast_util::is_local(def_id) => {
-                        match self.ast_map.get(def_id.node) {
-                          ast_map::NodeItem(item) =>
-                            self.visit_item(item),
-                          ast_map::NodeForeignItem(_) => {},
-                          _ => {
-                            self.sess.span_err(e.span,
-                              format!("expected item, found {}",
-                                      self.ast_map.node_to_string(def_id.node)).as_slice());
-                            return;
-                          },
-                        }
+                        self.visit_item(&*self.ast_map.expect_item(def_id.node));
                     }
                     _ => ()
                 }

trunk/src/librustc/middle/trans/expr.rs

@@ -833,7 +833,7 @@ fn trans_def<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
 
     let _icx = push_ctxt("trans_def_lvalue");
     match def {
-        def::DefFn(..) | def::DefStaticMethod(..) | def::DefMethod(..) |
+        def::DefFn(..) | def::DefStaticMethod(..) |
         def::DefStruct(_) | def::DefVariant(..) => {
             trans_def_fn_unadjusted(bcx, ref_expr, def)
         }
@@ -1191,12 +1191,10 @@ fn trans_def_fn_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
     let llfn = match def {
         def::DefFn(did, _, _) |
         def::DefStruct(did) | def::DefVariant(_, did, _) |
-        def::DefStaticMethod(did, def::FromImpl(_), _) |
-        def::DefMethod(did, _, def::FromImpl(_)) => {
+        def::DefStaticMethod(did, def::FromImpl(_), _) => {
             callee::trans_fn_ref(bcx, did, ExprId(ref_expr.id))
         }
-        def::DefStaticMethod(impl_did, def::FromTrait(trait_did), _) |
-        def::DefMethod(impl_did, _, def::FromTrait(trait_did)) => {
+        def::DefStaticMethod(impl_did, def::FromTrait(trait_did), _) => {
             meth::trans_static_method_callee(bcx, impl_did,
                                              trait_did, ref_expr.id)
         }

trunk/src/librustc/middle/ty.rs

@@ -3631,7 +3631,7 @@ pub fn expr_kind(tcx: &ctxt, expr: &ast::Expr) -> ExprKind {
                 def::DefFn(_, _, true) => RvalueDpsExpr,
 
                 // Fn pointers are just scalar values.
-                def::DefFn(..) | def::DefStaticMethod(..) | def::DefMethod(..) => RvalueDatumExpr,
+                def::DefFn(..) | def::DefStaticMethod(..) => RvalueDatumExpr,
 
                 // Note: there is actually a good case to be made that
                 // DefArg's, particularly those of immediate type, ought to

trunk/src/librustc/middle/typeck/astconv.rs

@@ -674,7 +674,7 @@ fn mk_pointer<'tcx, AC: AstConv<'tcx>, RS: RegionScope>(
                             return constr(ty::mk_str(tcx));
                         }
                         RPtr(r) => {
-                            return ty::mk_str_slice(tcx, r, a_seq_mutbl);
+                            return ty::mk_str_slice(tcx, r, ast::MutImmutable);
                         }
                     }
                 }

trunk/src/librustc/middle/typeck/check/method.rs

@@ -619,12 +619,14 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
 
         let tcx = self.tcx();
 
-        // It is illegal to invoke a method on a trait instance that refers to
-        // the `Self` type.  Here, we use a substitution that replaces `Self`
-        // with the object type itself. Hence, a `&self` method will wind up
-        // with an argument type like `&Trait`.
+        // It is illegal to invoke a method on a trait instance that
+        // refers to the `Self` type. An error will be reported by
+        // `enforce_object_limitations()` if the method refers to the
+        // `Self` type anywhere other than the receiver. Here, we use
+        // a substitution that replaces `Self` with the object type
+        // itself. Hence, a `&self` method will wind up with an
+        // argument type like `&Trait`.
         let rcvr_substs = substs.with_self_ty(self_ty);
-
         let trait_ref = Rc::new(TraitRef {
             def_id: did,
             substs: rcvr_substs.clone()
@@ -1334,7 +1336,16 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
                self.ty_to_string(rcvr_ty),
                candidate.repr(self.tcx()));
 
-        let rcvr_substs = candidate.rcvr_substs.clone();
+        let mut rcvr_substs = candidate.rcvr_substs.clone();
+
+        if !self.enforce_object_limitations(candidate) {
+            // Here we change `Self` from `Trait` to `err` in the case that
+            // this is an illegal object method. This is necessary to prevent
+            // the user from getting strange, derivative errors when the method
+            // takes an argument/return-type of type `Self` etc.
+            rcvr_substs.types.get_mut_slice(SelfSpace)[0] = ty::mk_err();
+        }
+
         self.enforce_drop_trait_limitations(candidate);
 
         // Determine the values for the generic parameters of the method.
@@ -1543,6 +1554,71 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
         }
     }
 
+    fn enforce_object_limitations(&self, candidate: &Candidate) -> bool {
+        /*!
+         * There are some limitations to calling functions through an
+         * object, because (a) the self type is not known
+         * (that's the whole point of a trait instance, after all, to
+         * obscure the self type) and (b) the call must go through a
+         * vtable and hence cannot be monomorphized.
+         */
+
+        match candidate.origin {
+            MethodStatic(..) |
+            MethodTypeParam(..) |
+            MethodStaticUnboxedClosure(..) => {
+                return true; // not a call to a trait instance
+            }
+            MethodTraitObject(..) => {}
+        }
+
+        match candidate.method_ty.explicit_self {
+            ty::StaticExplicitSelfCategory => { // reason (a) above
+                self.tcx().sess.span_err(
+                    self.span,
+                    "cannot call a method without a receiver \
+                     through an object");
+                return false;
+            }
+
+            ty::ByValueExplicitSelfCategory |
+            ty::ByReferenceExplicitSelfCategory(..) |
+            ty::ByBoxExplicitSelfCategory => {}
+        }
+
+        // reason (a) above
+        let check_for_self_ty = |ty| -> bool {
+            if ty::type_has_self(ty) {
+                span_err!(self.tcx().sess, self.span, E0038,
+                    "cannot call a method whose type contains a \
+                     self-type through an object");
+                false
+            } else {
+                true
+            }
+        };
+        let ref sig = candidate.method_ty.fty.sig;
+        for &input_ty in sig.inputs[1..].iter() {
+            if !check_for_self_ty(input_ty) {
+                return false;
+            }
+        }
+        if let ty::FnConverging(result_type) = sig.output {
+            if !check_for_self_ty(result_type) {
+                return false;
+            }
+        }
+
+        if candidate.method_ty.generics.has_type_params(subst::FnSpace) {
+            // reason (b) above
+            span_err!(self.tcx().sess, self.span, E0039,
+                "cannot call a generic method through an object");
+            return false;
+        }
+
+        true
+    }
+
     fn enforce_drop_trait_limitations(&self, candidate: &Candidate) {
         // No code can call the finalize method explicitly.
         let bad = match candidate.origin {

trunk/src/librustc/middle/typeck/check/mod.rs

@@ -1687,7 +1687,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 self.register_unsize_obligations(span, &**u)
             }
             ty::UnsizeVtable(ref ty_trait, self_ty) => {
-                vtable::check_object_safety(self.tcx(), ty_trait, span);
                 // If the type is `Foo+'a`, ensures that the type
                 // being cast to `Foo+'a` implements `Foo`:
                 vtable::register_object_cast_obligations(self,