---

yaml
---
r: 194036
b: refs/heads/beta
c: 5836efd
h: refs/heads/master
v: v3

Author: FuGangqiang

[refs]

@@ -31,7 +31,7 @@ refs/heads/automation-fail: 1bf06495443584539b958873e04cc2f864ab10e4
 refs/heads/issue-18208-method-dispatch-3-quick-reject: 2009f85b9f99dedcec4404418eda9ddba90258a2
 refs/heads/batch: b7fd822592a4fb577552d93010c4a4e14f314346
 refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
-refs/heads/beta: 5b9e87b5711361cb01bf3e066bc53c765f6dc5b9
+refs/heads/beta: 5836efdfe7077e10fe7ba69f0cb01d1ca93fa47b
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: de8a23bbc3a7b9cbd7574b5b91a34af59bf030e6

branches/beta/man/rustc.1

@@ -242,7 +242,7 @@ full debug info with variable and type information.
 \fBopt\-level\fR=\fIVAL\fR
 Optimize with possible levels 0\[en]3
 
-.SH ENVIRONMENT
+.SH ENVIRONMENT VARIABLES
 
 Some of these affect the output of the compiler, while others affect programs
 which link to the standard library.

branches/beta/src/doc/reference.md

@@ -1982,7 +1982,7 @@ the namespace hierarchy as it normally would.
 ## Attributes
 
 ```{.ebnf .gram}
-attribute : "#!" ? '[' meta_item ']' ;
+attribute : '#' '!' ? '[' meta_item ']' ;
 meta_item : ident [ '=' literal
                   | '(' meta_seq ')' ] ? ;
 meta_seq : meta_item [ ',' meta_seq ] ? ;

branches/beta/src/doc/trpl/SUMMARY.md

@@ -1,6 +1,6 @@
 # Summary
 
-* [The Basics](basic.md)
+* [I: The Basics](basic.md)
     * [Installing Rust](installing-rust.md)
     * [Hello, world!](hello-world.md)
     * [Hello, Cargo!](hello-cargo.md)
@@ -14,7 +14,7 @@
     * [Strings](strings.md)
     * [Arrays, Vectors, and Slices](arrays-vectors-and-slices.md)
     * [Standard Input](standard-input.md)
-* [Intermediate Rust](intermediate.md)
+* [II: Intermediate Rust](intermediate.md)
     * [Crates and Modules](crates-and-modules.md)
     * [Testing](testing.md)
     * [Pointers](pointers.md)
@@ -31,7 +31,7 @@
     * [Concurrency](concurrency.md)
     * [Error Handling](error-handling.md)
     * [Documentation](documentation.md)
-* [Advanced Topics](advanced.md)
+* [III: Advanced Topics](advanced.md)
     * [FFI](ffi.md)
     * [Unsafe Code](unsafe.md)
     * [Advanced Macros](advanced-macros.md)

branches/beta/src/libcollections/btree/map.rs

@@ -24,7 +24,7 @@ use core::default::Default;
 use core::fmt::Debug;
 use core::hash::{Hash, Hasher};
 use core::iter::{Map, FromIterator, IntoIterator};
-use core::ops::{Index};
+use core::ops::{Index, IndexMut};
 use core::{iter, fmt, mem, usize};
 use Bound::{self, Included, Excluded, Unbounded};
 
@@ -925,6 +925,15 @@ impl<K: Ord, Q: ?Sized, V> Index<Q> for BTreeMap<K, V>
     }
 }
 
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<K: Ord, Q: ?Sized, V> IndexMut<Q> for BTreeMap<K, V>
+    where K: Borrow<Q>, Q: Ord
+{
+    fn index_mut(&mut self, key: &Q) -> &mut V {
+        self.get_mut(key).expect("no entry found for key")
+    }
+}
+
 /// Genericises over how to get the correct type of iterator from the correct type
 /// of Node ownership.
 trait Traverse<N> {

branches/beta/src/librustc/README.md

@@ -0,0 +1,124 @@
+An informal guide to reading and working on the rustc compiler.
+==================================================================
+
+If you wish to expand on this document, or have a more experienced
+Rust contributor add anything else to it, please get in touch:
+
+* http://internals.rust-lang.org/
+* https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust
+
+or file a bug:
+
+https://github.com/rust-lang/rust/issues
+
+Your concerns are probably the same as someone else's.
+
+The crates of rustc
+===================
+
+Rustc consists of four crates altogether: `libsyntax`, `librustc`,
+`librustc_back`, and `librustc_trans` (the names and divisions are not
+set in stone and may change; in general, a finer-grained division of
+crates is preferable):
+
+- `libsyntax` contains those things concerned purely with syntax --
+  that is, the AST, parser, pretty-printer, lexer, macro expander, and
+  utilities for traversing ASTs -- are in a separate crate called
+  "syntax", whose files are in ./../libsyntax, where . is the current
+  directory (that is, the parent directory of front/, middle/, back/,
+  and so on).
+
+- `librustc` (the current directory) contains the high-level analysis
+  passes, such as the type checker, borrow checker, and so forth.
+  It is the heart of the compiler.
+
+- `librustc_back` contains some very low-level details that are
+  specific to different LLVM targets and so forth.
+
+- `librustc_trans` contains the code to convert from Rust IR into LLVM
+  IR, and then from LLVM IR into machine code, as well as the main
+  driver that orchestrates all the other passes and various other bits
+  of miscellany. In general it contains code that runs towards the
+  end of the compilation process.
+
+Roughly speaking the "order" of the three crates is as follows:
+
+    libsyntax -> librustc -> librustc_trans
+    |                                     |
+    +-----------------+-------------------+
+                      |
+             librustc_trans/driver
+
+Here the role of `librustc_trans/driver` is to invoke the compiler
+from libsyntax, then the analysis phases from librustc, and finally
+the lowering and codegen passes from librustc_trans.
+
+Modules in the rustc crate
+==========================
+
+The rustc crate itself consists of the following subdirectories
+(mostly, but not entirely, in their own directories):
+
+session  - options and data that pertain to the compilation session as a whole
+middle   - middle-end: name resolution, typechecking, LLVM code
+                  generation
+metadata - encoder and decoder for data required by
+                    separate compilation
+util     - ubiquitous types and helper functions
+lib      - bindings to LLVM
+
+The entry-point for the compiler is main() in the librustc_trans
+crate.
+
+The 3 central data structures:
+------------------------------
+
+#1: ./../libsyntax/ast.rs defines the AST. The AST is treated as immutable
+    after parsing, but it depends on mutable context data structures
+    (mainly hash maps) to give it meaning.
+
+      - Many -- though not all -- nodes within this data structure are
+        wrapped in the type `spanned<T>`, meaning that the front-end has
+        marked the input coordinates of that node. The member .node is
+        the data itself, the member .span is the input location (file,
+        line, column; both low and high).
+
+      - Many other nodes within this data structure carry a
+        def_id. These nodes represent the 'target' of some name
+        reference elsewhere in the tree. When the AST is resolved, by
+        middle/resolve.rs, all names wind up acquiring a def that they
+        point to. So anything that can be pointed-to by a name winds
+        up with a def_id.
+
+#2: middle/ty.rs defines the datatype sty.  This is the type that
+    represents types after they have been resolved and normalized by
+    the middle-end. The typeck phase converts every ast type to a
+    ty::sty, and the latter is used to drive later phases of
+    compilation.  Most variants in the ast::ty tag have a
+    corresponding variant in the ty::sty tag.
+
+#3: lib/llvm.rs (in librustc_trans) defines the exported types
+    ValueRef, TypeRef, BasicBlockRef, and several others. Each of
+    these is an opaque pointer to an LLVM type, manipulated through
+    the lib::llvm interface.
+
+
+Control and information flow within the compiler:
+-------------------------------------------------
+
+- main() in lib.rs assumes control on startup. Options are
+  parsed, platform is detected, etc.
+
+- ./../libsyntax/parse/parser.rs parses the input files and produces an AST
+  that represents the input crate.
+
+- Multiple middle-end passes (middle/resolve.rs, middle/typeck.rs)
+  analyze the semantics of the resulting AST. Each pass generates new
+  information about the AST and stores it in various environment data
+  structures. The driver passes environments to each compiler pass
+  that needs to refer to them.
+
+- Finally, the `trans` module in `librustc_trans` translates the Rust
+  AST to LLVM bitcode in a type-directed way. When it's finished
+  synthesizing LLVM values, rustc asks LLVM to write them out in some
+  form (.bc, .o) and possibly run the system linker.

branches/beta/src/librustc/README.txt

@@ -900,7 +900,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
             return;
         }
         if self.glob_map.contains_key(&import_id) {
-            self.glob_map.get_mut(&import_id).unwrap().insert(name);
+            self.glob_map[import_id].insert(name);
             return;
         }
 

branches/beta/src/librustc_resolve/lib.rs

@@ -603,7 +603,7 @@ impl<'a, 'b:'a, 'tcx:'b> ImportResolver<'a, 'b, 'tcx> {
 
         // We've successfully resolved the import. Write the results in.
         let mut import_resolutions = module_.import_resolutions.borrow_mut();
-        let import_resolution = import_resolutions.get_mut(&target).unwrap();
+        let import_resolution = &mut (*import_resolutions)[target];
 
         {
             let mut check_and_write_import = |namespace, result: &_, used_public: &mut bool| {

branches/beta/src/librustc_resolve/resolve_imports.rs

@@ -1 +1 @@
-See the README.md in ../librustc.
+See the README.txt in ../librustc.