---

yaml
---
r: 145307
b: refs/heads/try2
c: a95604f
h: refs/heads/master
i:
  145305: 99e5482
  145303: 4c564f3
v: v3

Author: bors

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 88bc11e646c8d1db7ac7894f74e2f660d9a82c54
+refs/heads/try2: a95604fcaacf9cbad5f57b8c08e1b3e871462e9c
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/Makefile.in

@@ -102,9 +102,9 @@ endif
 
 ifdef CFG_ENABLE_DEBUG
   $(info cfg: enabling more debugging (CFG_ENABLE_DEBUG))
-  CFG_RUSTC_FLAGS += --cfg debug
   CFG_GCCISH_CFLAGS += -DRUST_DEBUG
 else
+  CFG_RUSTC_FLAGS += --cfg ndebug
   CFG_GCCISH_CFLAGS += -DRUST_NDEBUG
 endif
 

branches/try2/README.md

@@ -61,7 +61,7 @@ documentation.
 
 [repo]: https://github.com/mozilla/rust
 [tarball]: http://static.rust-lang.org/dist/rust-0.7.tar.gz
-[tutorial]: http://static.rust-lang.org/doc/tutorial.html
+[tutorial]: http://static.rust-lang.org/doc/0.7/tutorial.html
 
 ## Notes
 

branches/try2/RELEASES.txt

@@ -1,3 +1,148 @@
+Version 0.8 (October 2013)
+--------------------------
+
+   * ~2100 changes, numerous bugfixes
+
+   * Language
+      * The `for` loop syntax has changed to work with the `Iterator` trait.
+      * At long last, unwinding works on Windows.
+      * Default methods definitely mostly work.
+      * Many trait inheritance bugs fixed.
+      * Owned and borrowed trait objects work more reliably.
+      * `copy` is no longer a keyword. It has been replaced by the `Clone` trait.
+      * rustc can omit emission of code for the `debug!` macro if it is passed
+        `--cfg ndebug`
+      * mod.rs is now "blessed". When loading `mod foo;`, rustc will now look
+        for foo.rs, then foo/mod.rs, and will generate an error when both are
+        present.
+      * Strings no longer contain trailing nulls. The new `std::c_str` module
+        provides new mechanisms for converting to C strings.
+      * The type of foreign functions is now `extern "C" fn` instead of `*u8'.
+      * The FFI has been overhauled such that foreign functions are called directly,
+        instead of through a stack-switching wrapper.
+      * Calling a foreign function must be done through a Rust function with the
+        `#[fixed_stack_segment]` attribute.
+      * The `externfn!` macro can be used to declare both a foreign function and
+        a `#[fixed_stack_segment]` wrapper at once.
+      * `pub` and `priv` modifiers on `extern` blocks are no longer parsed.
+      * `unsafe` is no longer allowed on extern fns - they are all unsafe.
+      * `priv` is disallowed everywhere except for struct fields and enum variants.
+      * `&T` (besides `&'static T`) is no longer allowed in `@T`.
+      * `ref` bindings in irrefutable patterns work correctly now.
+      * `char` is now prevented from containing invalid code points.
+      * Casting to `bool` is no longer allowed.
+      * `yield` is a reserved keyword.
+      * `typeof` is a reserved keyword.
+      * Crates may be imported by URL with `extern mod foo = "url";`.
+      * Explicit enum discriminants may be given as uints as in `enum E { V = 0u }`
+      * Static vectors can be initialized with repeating elements,
+        e.g. `static foo: [u8, .. 100]: [0, .. 100];`.
+      * Static structs can be initialized with functional record update,
+        e.g. `static foo: Foo = Foo { a: 5, .. bar };`.
+      * `cfg!` can be used to conditionally execute code based on the crate
+        configuration, similarly to `#[cfg(...)]`.
+      * The `unnecessary_qualification` lint detects unneeded module
+        prefixes (default: allow).
+      * Arithmetic operations have been implemented on the SIMD types in
+        `std::unstable::simd`.
+      * Exchange allocation headers were removed, reducing memory usage.
+      * `format!` implements a completely new, extensible, and higher-performance
+        string formatting system. It will replace `fmt!`.
+      * `print!` and `println!` write formatted strings (using the `format!`
+        extension) to stdout.
+      * `write!` and `writeln!` write formatted strings (using the `format!`
+        extension) to the new Writers in `std::rt::io`.
+      * The library section in which a function or static is placed may
+        be specified with `#[link_section = "..."]`.
+      * The `proto!` syntax extension for defining bounded message protocols
+        was removed.
+      * `macro_rules!` is hygenic for `let` declarations.
+      * The `#[export_name]` attribute specifies the name of a symbol.
+      * `unreachable!` can be used to indicate unreachable code, and fails
+        if executed.
+
+   * Libraries
+      * std: Transitioned to the new runtime, written in Rust.
+      * std: Added an experimental I/O library, `rt::io`, based on the new
+        runtime.
+      * std: A new generic `range` function was added to the prelude, replacing
+        `uint::range` and friends.
+      * std: `range_rev` no longer exists. Since range is an iterator it can be
+        reversed with `range(lo, hi).invert()`.
+      * std: The `chain` method on option renamed to `and_then`; `unwrap_or_default`
+        renamed to `unwrap_or`.
+      * std: The `iterator` module was renamed to `iter`.
+      * std: Integral types now support the `checked_add`, `checked_sub`, and
+        `checked_mul` operations for detecting overflow.
+      * std: Many methods in `str`, `vec`, `option, `result` were renamed for
+        consistency.
+      * std: Methods are standardizing on conventions for casting methods:
+        `to_foo` for copying, `into_foo` for moving, `as_foo` for temporary
+        and cheap casts.
+      * std: The `CString` type in `c_str` provides new ways to convert to and
+        from C strings.
+      * std: `DoubleEndedIterator` can yield elements in two directions.
+      * std: The `mut_split` method on vectors partitions an `&mut [T]` into
+        two splices.
+      * std: `str::from_bytes` renamed to `str::from_utf8`.
+      * std: `pop_opt` and `shift_opt` methods added to vectors.
+      * std: The task-local data interface no longer uses @, and keys are
+        no longer function pointers.
+      * std: The `swap_unwrap` method of `Option` renamed to `take_unwrap`.
+      * std: Added `SharedPort` to `comm`.
+      * std: `Eq` has a default method for `ne`; only `eq` is required
+        in implementations.
+      * std: `Ord` has default methods for `le`, `gt` and `le`; only `lt`
+        is required in implementations.
+      * std: `is_utf8` performance is improved, impacting many string functions.
+      * std: `os::MemoryMap` provides cross-platform mmap.
+      * std: `ptr::offset` is now unsafe, but also more optimized. Offsets that
+        are not 'in-bounds' are considered undefined.
+      * std: Many freestanding functions in `vec` removed in favor of methods.
+      * std: Many freestanding functions on scalar types removed in favor of
+        methods.
+      * std: Many options to task builders were removed since they don't make
+        sense in the new scheduler design.
+      * std: More containers implement `FromIterator` so can be created by the
+        `collect` method.
+      * std: More complete atomic types in `unstable::atomics`.
+      * std: `comm::PortSet` removed.
+      * std: Mutating methods in the `Set` and `Map` traits have been moved into
+        the `MutableSet` and `MutableMap` traits. `Container::is_empty`,
+        `Map::contains_key`, `MutableMap::insert`, and `MutableMap::remove` have
+        default implementations.
+      * extra: `dlist`, the doubly-linked list was modernized.
+      * extra: Added a `hex` module with `ToHex` and `FromHex` traits.
+      * extra: Added `glob` module, replacing `std::os::glob`.
+      * extra: `rope` was removed.
+      * extra: `deque` was renamed to `ringbuf`. `RingBuf` implements `Deque`.
+      * extra: `net`, and `timer` were removed. The experimental replacements
+        are `std::rt::io::net` and `std::rt::io::timer`.
+      * extra: Iterators implemented for `SmallIntMap`.
+      * extra: Iterators implemented for `Bitv` and `BitvSet`.
+      * extra: `SmallIntSet` removed. Use `BitvSet`.
+      * extra: Performance of JSON parsing greatly improved.
+      * extra: `semver` updated to SemVer 2.0.0.
+      * extra: `term` handles more terminals correctly.
+      * extra: `dbg` module removed.
+
+   * Other
+      * rustc's debug info generation (`-Z debug-info`) is greatly improved.
+      * rustc accepts `--target-cpu` to compile to a specific CPU architecture,
+        similarly to gcc's `--march` flag.
+      * rustpkg has received many improvements.
+      * rustpkg supports git tags as package IDs.
+      * rustpkg builds into target-specific directories so it can be used for
+        cross-compiling.
+      * The number of concurrent test tasks is controlled by the environment
+        variable RUST_TEST_TASKS.
+      * The test harness can now report metrics for benchmarks.
+      * All tools have man pages.
+      * Programs compiled with `--test` now support the `-h` and `--help` flags.
+      * The runtime uses jemalloc for allocations.
+      * Segmented stacks are temporarily disabled as part of the transition to
+        the new runtime. Stack overflows are possible!
+
 Version 0.7 (July 2013)
 -----------------------
 

branches/try2/configure

@@ -373,7 +373,7 @@ opt optimize-cxx 1 "build optimized C++ code"
 opt optimize-llvm 1 "build optimized LLVM"
 opt optimize-tests 1 "build tests with optimizations"
 opt llvm-assertions 1 "build LLVM with assertions"
-opt debug 0 "build with extra debug fun"
+opt debug 1 "build with extra debug fun"
 opt ratchet-bench 0 "ratchet benchmarks"
 opt fast-make 0 "use .gitmodules as timestamp for submodule deps"
 opt manage-submodules 1 "let the build manage the git submodules"

branches/try2/doc/rust.md

@@ -248,7 +248,7 @@ string_body : non_double_quote
             | '\x5c' [ '\x22' | common_escape ] ;
 
 common_escape : '\x5c'
-              | 'n' | 'r' | 't'
+              | 'n' | 'r' | 't' | '0'
               | 'x' hex_digit 2
               | 'u' hex_digit 4
               | 'U' hex_digit 8 ;
@@ -962,24 +962,76 @@ parameters to allow methods with that trait to be called on values
 of that type.
 
 
-#### Unsafe functions
-
-Unsafe functions are those containing unsafe operations that are not contained in an [`unsafe` block](#unsafe-blocks).
-Such a function must be prefixed with the keyword `unsafe`.
+#### Unsafety
 
 Unsafe operations are those that potentially violate the memory-safety guarantees of Rust's static semantics.
-Specifically, the following operations are considered unsafe:
+
+The following language level features cannot be used in the safe subset of Rust:
 
   - Dereferencing a [raw pointer](#pointer-types).
-  - Casting a [raw pointer](#pointer-types) to a safe pointer type.
-  - Calling an unsafe function.
+  - Calling an unsafe function (including an intrinsic or foreign function).
 
-##### Unsafe blocks
+##### Unsafe functions
 
-A block of code can also be prefixed with the `unsafe` keyword, to permit a sequence of unsafe operations in an otherwise-safe function.
-This facility exists because the static semantics of Rust are a necessary approximation of the dynamic semantics.
-When a programmer has sufficient conviction that a sequence of unsafe operations is actually safe, they can encapsulate that sequence (taken as a whole) within an `unsafe` block. The compiler will consider uses of such code "safe", to the surrounding context.
+Unsafe functions are functions that are not safe in all contexts and/or for all possible inputs.
+Such a function must be prefixed with the keyword `unsafe`.
+
+##### Unsafe blocks
 
+A block of code can also be prefixed with the `unsafe` keyword, to permit calling `unsafe` functions
+or dereferencing raw pointers within a safe function.
+
+When a programmer has sufficient conviction that a sequence of potentially unsafe operations is
+actually safe, they can encapsulate that sequence (taken as a whole) within an `unsafe` block. The
+compiler will consider uses of such code safe, in the surrounding context.
+
+Unsafe blocks are used to wrap foreign libraries, make direct use of hardware or implement features
+not directly present in the language. For example, Rust provides the language features necessary to
+implement memory-safe concurrency in the language but the implementation of tasks and message
+passing is in the standard library.
+
+Rust's type system is a conservative approximation of the dynamic safety requirements, so in some
+cases there is a performance cost to using safe code.  For example, a doubly-linked list is not a
+tree structure and can only be represented with managed or reference-counted pointers in safe code.
+By using `unsafe` blocks to represent the reverse links as raw pointers, it can be implemented with
+only owned pointers.
+
+##### Behavior considered unsafe
+
+This is a list of behavior which is forbidden in all Rust code. Type checking provides the guarantee
+that these issues are never caused by safe code. An `unsafe` block or function is responsible for
+never invoking this behaviour or 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, if it is not marked as non-`Freeze`
+* Reads of [undef](http://llvm.org/docs/LangRef.html#undefined-values) (uninitialized) memory
+* Breaking the [pointer aliasing rules](http://llvm.org/docs/LangRef.html#pointer-aliasing-rules)
+  with raw pointers (a subset of the rules used by C)
+* Invoking undefined behavior via compiler intrinsics:
+    * Indexing outside of the bounds of an object with `std::ptr::offset` (`offset` intrinsic), with
+      the exception of one byte past the end which is permitted.
+    * Using `std::ptr::copy_nonoverlapping_memory` (`memcpy32`/`memcpy64` instrinsics) on
+      overlapping buffers
+* Invalid values in primitive types, even in private fields/locals:
+    * 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`
+
+##### Behaviour not considered unsafe
+
+This is a list of behaviour not considered *unsafe* in Rust terms, but that may be undesired.
+
+* Deadlocks
+* Reading data from private fields (`std::repr`, `format!("{:?}", x)`)
+* Leaks due to reference count cycles, even in the global heap
+* Exiting without calling destructors
+* Sending signals
+* Accessing/modifying the file system
+* Unsigned integer overflow (well-defined as wrapping)
+* Signed integer overflow (well-defined as two's complement representation wrapping)
 
 #### Diverging functions
 
@@ -3376,8 +3428,8 @@ sign (`=`) followed by the log level, from 1 to 4, inclusive. Level 1
 is the error level, 2 is warning, 3 info, and 4 debug. You can also
 use the symbolic constants `error`, `warn`, `info`, and `debug`.  Any
 logs less than or equal to the specified level will be output. If not
-specified then log level 4 is assumed.  However, debug messages are
-only available if `--cfg=debug` is passed to `rustc`.
+specified then log level 4 is assumed.  Debug messages can be omitted
+by passing `--cfg ndebug` to `rustc`.
 
 As an example, to see all the logs generated by the compiler, you would set
 `RUST_LOG` to `rustc`, which is the crate name (as specified in its `link`