---

yaml
---
r: 54162
b: refs/heads/dist-snap
c: e11d13f
h: refs/heads/master
v: v3

Author: nikomatsakis

[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: bbc4ca134900456ba2a00368ec1f19bc1a357528
+refs/heads/dist-snap: e11d13f3de084fe73d754ca206ad70737bb5957d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

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

@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Unsafe casting functions
-
 pub mod rusti {
     #[abi = "rust-intrinsic"]
     #[link_name = "rusti"]

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

@@ -8,17 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! A mutable, nullable memory location
-
 use cast::transmute;
 use option;
 use prelude::*;
 
-/*
-A dynamic, mutable location.
-
-Similar to a mutable option type, but friendlier.
-*/
+/// A dynamic, mutable location.
+///
+/// Similar to a mutable option type, but friendlier.
 
 pub struct Cell<T> {
     mut value: Option<T>

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

@@ -8,20 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-/*! The Clone trait for types that cannot be "implicitly copied"
-
-In Rust, some simple types are "implicitly copyable" and when you
-assign them or pass them as arguments, the receiver will get a copy,
-leaving the original value in place. These types do not require
-allocation to copy and do not have finalizers (i.e. they do not
-contain owned pointers or implement `Drop`), so the compiler considers
-them cheap and safe to copy and automatically implements the `Copy`
-trait for them. For other types copies must be made explicitly,
-by convention implementing the `Clone` trait and calling the
-`clone` method.
-
+/**
+Clonable types are copied with the clone method
 */
-
 pub trait Clone {
     fn clone(&self) -> Self;
 }

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

@@ -8,10 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-/*!
-Message passing
-*/
-
 use cast;
 use either::{Either, Left, Right};
 use kinds::Owned;

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

@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-/*! Condition handling */
-
 use prelude::*;
 use task;
 use task::local_data::{local_data_pop, local_data_set};

branches/dist-snap/src/libcore/core.rc

@@ -10,39 +10,27 @@
 
 /*!
 
-# The Rust core library
+The Rust core library
 
 The Rust core library provides runtime features required by the language,
 including the task scheduler and memory allocators, as well as library
 support for Rust built-in types, platform abstractions, and other commonly
 used features.
 
 `core` includes modules corresponding to each of the integer types, each of
-the floating point types, the `bool` type, tuples, characters, strings
-(`str`), vectors (`vec`), managed boxes (`managed`), owned boxes (`owned`),
-and unsafe and borrowed pointers (`ptr`).  Additionally, `core` provides
-pervasive types (`option` and `result`), task creation and communication
-primitives (`task`, `comm`), platform abstractions (`os` and `path`), basic
-I/O abstractions (`io`), common traits (`kinds`, `ops`, `cmp`, `num`,
-`to_str`), and complete bindings to the C standard library (`libc`).
+the floating point types, the `bool` type, tuples, characters, strings,
+vectors (`vec`), managed boxes (`managed`), owned boxes (`owned`), and unsafe
+and borrowed pointers (`ptr`).  Additionally, `core` provides task management
+and creation (`task`), communication primitives (`comm` and `pipes`), platform
+abstractions (`os` and `path`), basic I/O abstractions (`io`), common traits
+(`cmp`, `num`, `to_str`), and complete bindings to the C standard library
+(`libc`).
 
-# Core injection and the Rust prelude
-
-`core` is imported at the topmost level of every crate by default, as
-if the first line of each crate was
+`core` is linked to all crates by default and its contents imported.
+Implicitly, all crates behave as if they included the following prologue:
 
     extern mod core;
-
-This means that the contents of core can be accessed from from any context
-with the `core::` path prefix, as in `use core::vec`, `use core::task::spawn`,
-etc.
-
-Additionally, `core` contains a `prelude` module that reexports many of the
-most common core modules, types and traits. The contents of the prelude are
-imported inte every *module* by default.  Implicitly, all modules behave as if
-they contained the following prologue:
-
-    use core::prelude::*;
+    use core::*;
 
 */
 

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

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! The Rust prelude. Imported into every module by default.
+// This file is imported into every module by default.
 
 /* Reexported core operators */
 

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

@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#[doc(hidden)];
-
 use libc::c_char;
 
 // Some basic logging

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

@@ -1321,13 +1321,7 @@ 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.
-        match f.node {
-            ast::expr_field(ref base, ref field, ref tys) => {
-                check_field(fcx, f, true, *base, *field, *tys)
-            }
-            _ => check_expr(fcx, f)
-        };
-
+        let mut bot = check_expr(fcx, f);
         check_call_or_method(fcx,
                              sp,
                              call_expr_id,
@@ -1689,7 +1683,6 @@ 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]) {
@@ -1723,7 +1716,6 @@ 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,
@@ -1734,34 +1726,30 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
                              DontDerefArgs,
                              CheckTraitsAndInherentMethods,
                              AutoderefReceiver) {
-            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);
-                }
+            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);
             }
+
             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.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.write_error(expr.id);
     }
 
     fn check_struct_or_variant_fields(fcx: @mut FnCtxt,
@@ -2750,15 +2738,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
         }
       }
       ast::expr_field(base, field, ref 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
+        check_field(fcx, expr, base, field, *tys);
       }
       ast::expr_index(base, idx) => {
           check_expr(fcx, base);