---

yaml
---
r: 209375
b: refs/heads/auto
c: 23ec007
h: refs/heads/master
i:
  209373: 60aeca7
  209371: 57d0516
  209367: 2e64ef2
  209359: 4af750b
  209343: 082b8e6
v: v3

Author: reinh

[refs]

@@ -10,7 +10,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 4f66d881a54d1f94d0684174b9c5cc32fe8e69ce
+refs/heads/auto: 23ec00751e8da1b8f138745cfcf6d861c0987915
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/doc/complement-design-faq.md

@@ -160,7 +160,7 @@ that all delimiters be balanced.
 ## `->` for function return type
 
 This is to make the language easier to parse for humans, especially in the face
-of higher-order functions. `fn foo<T>(f: fn(i32): i32, fn(T): U): U` is not
+of higher-order functions. `fn foo<T>(f: fn(int): int, fn(T): U): U` is not
 particularly easy to read.
 
 ## Why is `let` used to introduce variables?

branches/auto/src/doc/style/errors/ergonomics.md

@@ -14,8 +14,8 @@ use std::io::{File, Open, Write, IoError};
 
 struct Info {
     name: String,
-    age: i32,
-    rating: i32
+    age: int,
+    rating: int
 }
 
 fn write_info(info: &Info) -> Result<(), IoError> {
@@ -36,8 +36,8 @@ use std::io::{File, Open, Write, IoError};
 
 struct Info {
     name: String,
-    age: i32,
-    rating: i32
+    age: int,
+    rating: int
 }
 
 fn write_info(info: &Info) -> Result<(), IoError> {

branches/auto/src/doc/style/features/functions-and-methods/input.md

@@ -57,15 +57,15 @@ it becomes.
 Prefer
 
 ```rust
-fn foo<T: Iterator<i32>>(c: T) { ... }
+fn foo<T: Iterator<int>>(c: T) { ... }
 ```
 
 over any of
 
 ```rust
-fn foo(c: &[i32]) { ... }
-fn foo(c: &Vec<i32>) { ... }
-fn foo(c: &SomeOtherCollection<i32>) { ... }
+fn foo(c: &[int]) { ... }
+fn foo(c: &Vec<int>) { ... }
+fn foo(c: &SomeOtherCollection<int>) { ... }
 ```
 
 if the function only needs to iterate over the data.
@@ -121,7 +121,7 @@ The primary exception: sometimes a function is meant to modify data
 that the caller already owns, for example to re-use a buffer:
 
 ```rust
-fn read(&mut self, buf: &mut [u8]) -> IoResult<usize>
+fn read(&mut self, buf: &mut [u8]) -> IoResult<uint>
 ```
 
 (From the [Reader trait](http://static.rust-lang.org/doc/master/std/io/trait.Reader.html#tymethod.read).)

branches/auto/src/doc/style/features/functions-and-methods/output.md

@@ -19,15 +19,15 @@ Prefer
 ```rust
 struct SearchResult {
     found: bool,          // item in container?
-    expected_index: usize // what would the item's index be?
+    expected_index: uint  // what would the item's index be?
 }
 
 fn binary_search(&self, k: Key) -> SearchResult
 ```
 or
 
 ```rust
-fn binary_search(&self, k: Key) -> (bool, usize)
+fn binary_search(&self, k: Key) -> (bool, uint)
 ```
 
 over

branches/auto/src/doc/style/features/let.md

@@ -5,7 +5,7 @@
 Prefer
 
 ```rust
-fn use_mutex(m: sync::mutex::Mutex<i32>) {
+fn use_mutex(m: sync::mutex::Mutex<int>) {
     let guard = m.lock();
     do_work(guard);
     drop(guard); // unlock the lock
@@ -16,7 +16,7 @@ fn use_mutex(m: sync::mutex::Mutex<i32>) {
 over
 
 ```rust
-fn use_mutex(m: sync::mutex::Mutex<i32>) {
+fn use_mutex(m: sync::mutex::Mutex<int>) {
     do_work(m.lock());
     // do other work
 }

branches/auto/src/doc/style/features/traits/reuse.md

@@ -15,7 +15,7 @@ trait Printable {
     fn print(&self) { println!("{:?}", *self) }
 }
 
-impl Printable for i32 {}
+impl Printable for int {}
 
 impl Printable for String {
     fn print(&self) { println!("{}", *self) }

branches/auto/src/doc/style/features/types/newtype.md

@@ -43,12 +43,12 @@ promises to the client.
 
 For example, consider a function `my_transform` that returns a compound iterator
 type `Enumerate<Skip<vec::MoveItems<T>>>`. We wish to hide this type from the
-client, so that the client's view of the return type is roughly `Iterator<(usize,
+client, so that the client's view of the return type is roughly `Iterator<(uint,
 T)>`. We can do so using the newtype pattern:
 
 ```rust
 struct MyTransformResult<T>(Enumerate<Skip<vec::MoveItems<T>>>);
-impl<T> Iterator<(usize, T)> for MyTransformResult<T> { ... }
+impl<T> Iterator<(uint, T)> for MyTransformResult<T> { ... }
 
 fn my_transform<T, Iter: Iterator<T>>(iter: Iter) -> MyTransformResult<T> {
     ...

branches/auto/src/doc/style/style/features.md

@@ -3,7 +3,7 @@
 Terminate `return` statements with semicolons:
 
 ``` rust
-fn foo(bar: i32) -> Option<i32> {
+fn foo(bar: int) -> Option<int> {
     if some_condition() {
         return None;
     }

branches/auto/src/doc/style/style/imports.md

@@ -44,7 +44,7 @@ For example:
 use option::Option;
 use mem;
 
-let i: isize = mem::transmute(Option(0));
+let i: int = mem::transmute(Option(0));
 ```
 
 > **[FIXME]** Add rationale.

branches/auto/src/doc/style/style/whitespace.md

@@ -10,7 +10,7 @@
 
 ``` rust
 #[deprecated = "Use `bar` instead."]
-fn foo(a: usize, b: usize) -> usize {
+fn foo(a: uint, b: uint) -> uint {
     a + b
 }
 ```

branches/auto/src/doc/trpl/associated-types.md

@@ -43,7 +43,7 @@ trait Graph {
 Now, our clients can be abstract over a given `Graph`:
 
 ```rust,ignore
-fn distance<G: Graph>(graph: &G, start: &G::N, end: &G::N) -> usize { ... }
+fn distance<G: Graph>(graph: &G, start: &G::N, end: &G::N) -> uint { ... }
 ```
 
 No need to deal with the `E`dge type here!

branches/auto/src/doc/trpl/box-syntax-and-patterns.md

@@ -58,7 +58,7 @@ fn main() {
 ```
 
 The idea is that by passing around a box, you're only copying a pointer, rather
-than the hundred `i32`s that make up the `BigStruct`.
+than the hundred `int`s that make up the `BigStruct`.
 
 This is an antipattern in Rust. Instead, write this:
 

branches/auto/src/doc/trpl/references-and-borrowing.md

@@ -206,7 +206,7 @@ fn main() {
 ^
 ```
 
-In other words, the mutable borow is held through the rest of our example. What
+In other words, the mutable borrow is held through the rest of our example. What
 we want is for the mutable borrow to end _before_ we try to call `println!` and
 make an immutable borrow. In Rust, borrowing is tied to the scope that the
 borrow is valid for. And our scopes look like this:

branches/auto/src/doc/trpl/traits.md

@@ -146,7 +146,7 @@ print_area(5);
 We get a compile-time error:
 
 ```text
-error: the trait `HasArea` is not implemented for the type `_` [E0277]
+error: failed to find an implementation of trait main::HasArea for int
 ```
 
 So far, we’ve only added trait implementations to structs, but you can

branches/auto/src/libcore/num/isize.rs

@@ -9,6 +9,10 @@
 // except according to those terms.
 
 //! Operations and constants for pointer-sized signed integers (`isize` type)
+//!
+//! This type was recently added to replace `int`. The rollout of the
+//! new type will gradually take place over the alpha cycle along with
+//! the development of clearer conventions around integer types.
 
 #![stable(feature = "rust1", since = "1.0.0")]
 #![doc(primitive = "isize")]

branches/auto/src/libcore/num/usize.rs

@@ -9,6 +9,10 @@
 // except according to those terms.
 
 //! Operations and constants for pointer-sized unsigned integers (`usize` type)
+//!
+//! This type was recently added to replace `uint`. The rollout of the
+//! new type will gradually take place over the alpha cycle along with
+//! the development of clearer conventions around integer types.
 
 #![stable(feature = "rust1", since = "1.0.0")]
 #![doc(primitive = "usize")]

branches/auto/src/librustc_trans/save/dump_csv.rs

@@ -508,7 +508,7 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> {
             self.process_formals(&decl.inputs, &fn_data.qualname);
             self.process_generic_params(ty_params, item.span, &fn_data.qualname, item.id);
         } else {
-            self.sess.span_bug(item.span, "expected FunctionData");
+            unreachable!();
         }
 
         for arg in &decl.inputs {
@@ -538,7 +538,7 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> {
                                 &var_data.type_value,
                                 var_data.scope);
         } else {
-            self.sess.span_bug(item.span, "expected VariableData");
+            unreachable!();
         }
 
         self.visit_ty(&typ);
@@ -768,18 +768,22 @@ impl <'l, 'tcx> DumpCsvVisitor<'l, 'tcx> {
     }
 
     fn process_mod(&mut self,
-                   item: &ast::Item) {  // The module in question, represented as an item.
-        let mod_data = self.save_ctxt.get_item_data(item);
-        if let super::Data::ModData(mod_data) = mod_data {
-            self.fmt.mod_str(item.span,
-                             Some(mod_data.span),
-                             mod_data.id,
-                             &mod_data.qualname,
-                             mod_data.scope,
-                             &mod_data.filename);
-        } else {
-            self.sess.span_bug(item.span, "expected ModData");
-        }
+                   item: &ast::Item,  // The module in question, represented as an item.
+                   m: &ast::Mod) {
+        let qualname = format!("::{}", self.analysis.ty_cx.map.path_to_string(item.id));
+
+        let cm = self.sess.codemap();
+        let filename = cm.span_to_filename(m.inner);
+
+        let sub_span = self.span.sub_span_after_keyword(item.span, keywords::Mod);
+        self.fmt.mod_str(item.span,
+                         sub_span,
+                         item.id,
+                         &qualname[..],
+                         self.cur_scope,
+                         &filename[..]);
+
+        self.nest(item.id, |v| visit::walk_mod(v, m));
     }
 
     fn process_path(&mut self,
@@ -1184,10 +1188,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DumpCsvVisitor<'l, 'tcx> {
             }
             ast::ItemTrait(_, ref generics, ref trait_refs, ref methods) =>
                 self.process_trait(item, generics, trait_refs, methods),
-            ast::ItemMod(ref m) => {
-                self.process_mod(item);
-                self.nest(item.id, |v| visit::walk_mod(v, m));
-            }
+            ast::ItemMod(ref m) => self.process_mod(item, m),
             ast::ItemTy(ref ty, ref ty_params) => {
                 let qualname = format!("::{}", self.analysis.ty_cx.map.path_to_string(item.id));
                 let value = ty_to_string(&**ty);
@@ -1294,22 +1295,30 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DumpCsvVisitor<'l, 'tcx> {
             ast::ExprStruct(ref path, ref fields, ref base) =>
                 self.process_struct_lit(ex, path, fields, base),
             ast::ExprMethodCall(_, _, ref args) => self.process_method_call(ex, args),
-            ast::ExprField(ref sub_ex, _) => {
+            ast::ExprField(ref sub_ex, ident) => {
                 if generated_code(sub_ex.span) {
                     return
                 }
 
-                self.visit_expr(&sub_ex);
-
-                let field_data = self.save_ctxt.get_expr_data(ex);
-                if let super::Data::VariableRefData(field_data) = field_data {
-                    self.fmt.ref_str(recorder::VarRef,
-                                     ex.span,
-                                     Some(field_data.span),
-                                     field_data.ref_id,
-                                     field_data.scope);
-                } else {
-                    self.sess.span_bug(ex.span, "expected VariableRefData");
+                self.visit_expr(&**sub_ex);
+                let ty = &ty::expr_ty_adjusted(&self.analysis.ty_cx, &**sub_ex).sty;
+                match *ty {
+                    ty::ty_struct(def_id, _) => {
+                        let fields = ty::lookup_struct_fields(&self.analysis.ty_cx, def_id);
+                        for f in &fields {
+                            if f.name == ident.node.name {
+                                let sub_span = self.span.span_for_last_ident(ex.span);
+                                self.fmt.ref_str(recorder::VarRef,
+                                                 ex.span,
+                                                 sub_span,
+                                                 f.id,
+                                                 self.cur_scope);
+                                break;
+                            }
+                        }
+                    }
+                    _ => self.sess.span_bug(ex.span,
+                                            &format!("Expected struct type, found {:?}", ty)),
                 }
             },
             ast::ExprTupField(ref sub_ex, idx) => {