---

yaml
---
r: 51678
b: refs/heads/incoming
c: f792d17
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 8eb2bab100b42f0ba751552d8eff00eb2134c55a
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/incoming: 6f2783d5151cb8e9ee3aa9ab591b65847042cf1b
+refs/heads/incoming: f792d177a493aa3ced268ed4d6815baef5ab8d29
 refs/heads/dist-snap: 8b98e5a296d95c5e832db0756828e5bec31c6f50
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/src/libcore/gc.rs

@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#[doc(hidden)];
+
 /*! Precise garbage collector
 
 The precise GC exposes two functions, gc and

branches/incoming/src/libcore/unstable/lang.rs

@@ -99,12 +99,8 @@ pub unsafe fn borrow_as_imm(a: *u8) {
 #[lang="return_to_mut"]
 #[inline(always)]
 pub unsafe fn return_to_mut(a: *u8) {
-    // Sometimes the box is null, if it is conditionally frozen.
-    // See e.g. #4904.
-    if !a.is_null() {
-        let a: *mut BoxRepr = transmute(a);
-        (*a).header.ref_count &= !FROZEN_BIT;
-    }
+    let a: *mut BoxRepr = transmute(a);
+    (*a).header.ref_count &= !FROZEN_BIT;
 }
 
 #[lang="check_not_borrowed"]

branches/incoming/src/librustc/middle/trans/base.rs

@@ -1579,15 +1579,7 @@ pub fn new_fn_ctxt_w_id(ccx: @CrateContext,
                         id: ast::node_id,
                         impl_id: Option<ast::def_id>,
                         param_substs: Option<@param_substs>,
-                        sp: Option<span>) -> fn_ctxt
-{
-    debug!("new_fn_ctxt_w_id(path=%s, id=%?, impl_id=%?, \
-            param_substs=%s",
-           path_str(ccx.sess, path),
-           id,
-           impl_id,
-           opt_param_substs_to_str(ccx.tcx, &param_substs));
-
+                        sp: Option<span>) -> fn_ctxt {
     let llbbs = mk_standard_basic_blocks(llfndecl);
     return @mut fn_ctxt_ {
           llfn: llfndecl,

branches/incoming/src/librustc/middle/trans/callee.rs

@@ -217,7 +217,7 @@ pub fn trans_fn_ref_with_vtables(
     // - `type_params`: values for each of the fn/method's type parameters
     // - `vtables`: values for each bound on each of the type parameters
 
-    let _icx = bcx.insn_ctxt("trans_fn_ref_with_vtables");
+    let _icx = bcx.insn_ctxt("trans_fn_with_vtables");
     let ccx = bcx.ccx();
     let tcx = ccx.tcx;
 

branches/incoming/src/librustc/middle/trans/common.rs

@@ -257,11 +257,6 @@ pub fn param_substs_to_str(tcx: ty::ctxt, substs: &param_substs) -> ~str {
          substs.bounds.map(|b| ty::param_bounds_to_str(tcx, *b)))
 }
 
-pub fn opt_param_substs_to_str(tcx: ty::ctxt,
-                               substs: &Option<@param_substs>) -> ~str {
-    substs.map_default(~"None", |&ps| param_substs_to_str(tcx, ps))
-}
-
 // Function context.  Every LLVM function we create will have one of
 // these.
 pub struct fn_ctxt_ {
@@ -1428,7 +1423,7 @@ pub fn resolve_vtable_in_fn_ctxt(fcx: fn_ctxt, +vt: typeck::vtable_origin)
 }
 
 pub fn find_vtable(tcx: ty::ctxt, ps: &param_substs,
-                   n_param: uint, n_bound: uint)
+               n_param: uint, n_bound: uint)
     -> typeck::vtable_origin {
     debug!("find_vtable_in_fn_ctxt(n_param=%u, n_bound=%u, ps=%?)",
            n_param, n_bound, param_substs_to_str(tcx, ps));

branches/incoming/src/librustc/middle/trans/meth.rs

@@ -175,9 +175,6 @@ pub fn trans_method_callee(bcx: block,
                         -> Callee {
     let _icx = bcx.insn_ctxt("impl::trans_method_callee");
 
-    debug!("trans_method_callee(callee_id=%?, self=%s, mentry=%?)",
-           callee_id, bcx.expr_to_str(self), mentry);
-
     // Replace method_self with method_static here.
     let mut origin = mentry.origin;
     match origin {
@@ -221,8 +218,6 @@ pub fn trans_method_callee(bcx: block,
         typeck::method_trait(*) => {}
     }
 
-    debug!("origin=%?", origin);
-
     match origin {
         typeck::method_static(did) => {
             let callee_fn = callee::trans_fn_ref(bcx, did, callee_id);

branches/incoming/src/librustc/middle/trans/monomorphize.rs

@@ -67,11 +67,9 @@ pub fn monomorphic_fn(ccx: @CrateContext,
         must_cast = true;
     }
 
-    debug!("monomorphic_fn(fn_id=%? (%s), vtables=%?, \
-            real_substs=%?, substs=%?, \
-            hash_id = %?",
+    debug!("monomorphic_fn(fn_id=%? (%s), real_substs=%?, substs=%?, \
+           hash_id = %?",
            fn_id, ty::item_path_str(ccx.tcx, fn_id),
-           vtables,
            real_substs.map(|s| ty_to_str(ccx.tcx, *s)),
            substs.map(|s| ty_to_str(ccx.tcx, *s)), hash_id);
 

branches/incoming/src/librustc/middle/typeck/check/mod.rs

@@ -1321,7 +1321,13 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
                   sugar: ast::CallSugar) {
         // Index expressions need to be handled separately, to inform them
         // that they appear in call position.
-        let mut bot = check_expr(fcx, f);
+        match f.node {
+            ast::expr_field(ref base, ref field, ref tys) => {
+                check_field(fcx, f, true, *base, *field, *tys)
+            }
+            _ => check_expr(fcx, f)
+        };
+
         check_call_or_method(fcx,
                              sp,
                              call_expr_id,
@@ -1683,6 +1689,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
     // Check field access expressions
     fn check_field(fcx: @mut FnCtxt,
                    expr: @ast::expr,
+                   is_callee: bool,
                    base: @ast::expr,
                    field: ast::ident,
                    tys: &[@ast::Ty]) {
@@ -1716,6 +1723,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
         }
 
         let tps = vec::map(tys, |ty| fcx.to_ty(*ty));
+
         match method::lookup(fcx,
                              expr,
                              base,
@@ -1726,30 +1734,34 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
                              DontDerefArgs,
                              CheckTraitsAndInherentMethods,
                              AutoderefReceiver) {
-            Some(_) => {
-                fcx.type_error_message(
-                    expr.span,
-                    |actual| {
-                        fmt!("attempted to take value of method `%s` on type `%s` \
-                              (try writing an anonymous function)",
-                             *tcx.sess.str_of(field), actual)
-                    },
-                    expr_t, None);
-            }
+            Some(ref entry) => {
+                let method_map = fcx.ccx.method_map;
+                method_map.insert(expr.id, (*entry));
 
+                // If we have resolved to a method but this is not in
+                // a callee position, error
+                if !is_callee {
+                    tcx.sess.span_err(
+                        expr.span,
+                        ~"attempted to take value of method \
+                          (try writing an anonymous function)");
+                    // Add error type for the result
+                    fcx.write_error(expr.id);
+                }
+            }
             None => {
-                fcx.type_error_message(
-                    expr.span,
-                    |actual| {
-                        fmt!("attempted access of field `%s` on type `%s`, \
-                              but no field with that name was found",
-                             *tcx.sess.str_of(field), actual)
-                    },
-                    expr_t, None);
+                fcx.type_error_message(expr.span,
+                  |actual| {
+                      fmt!("attempted access of field `%s` on type `%s`, but \
+                            no field or method with that name was found",
+                           *tcx.sess.str_of(field), actual)
+                  },
+                  expr_t, None);
+                // Add error type for the result
+                fcx.write_error(expr.id);
             }
         }
 
-        fcx.write_error(expr.id);
     }
 
     fn check_struct_or_variant_fields(fcx: @mut FnCtxt,
@@ -2738,7 +2750,15 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
         }
       }
       ast::expr_field(base, field, ref tys) => {
-        check_field(fcx, expr, base, field, *tys);
+          check_field(fcx, expr, false, base, field, * tys);
+          let base_t = fcx.expr_ty(base);
+          if ty::type_is_error(base_t) {
+              fcx.write_error(id);
+          }
+          else if ty::type_is_bot(base_t) {
+              fcx.write_bot(id);
+          }
+          // Otherwise, type already got written
       }
       ast::expr_index(base, idx) => {
           check_expr(fcx, base);

branches/incoming/src/librustc/middle/typeck/check/regionck.rs

@@ -615,7 +615,7 @@ pub mod guarantor {
         // expressions, both of which always yield a region variable, so
         // mk_subr should never fail.
         let rptr_ty = rcx.resolve_node_type(id);
-        if !ty::type_is_error(rptr_ty) && !ty::type_is_bot(rptr_ty) {
+        if !ty::type_is_error(rptr_ty) {
             let tcx = rcx.fcx.ccx.tcx;
             debug!("rptr_ty=%s", ty_to_str(tcx, rptr_ty));
             let r = ty::ty_region(tcx, span, rptr_ty);