---

yaml
---
r: 142896
b: refs/heads/try2
c: 3c19f1b
h: refs/heads/master
v: v3

Author: pnkfelix

[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: 9db190305f7562f15b5282fed508aef81cfc9689
+refs/heads/try2: 3c19f1bca83be3f4abef378d0a4cd852c8615164
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/Makefile.in

@@ -235,39 +235,6 @@ LIBRUST_DSYM_GLOB_$(1) :=$(call CFG_LIB_DSYM_GLOB_$(1),rust)
 
 endef
 
-# $(1) is the path for directory to match against
-# $(2) is the glob to use in the match
-# $(3) is filename (usually the target being created) to filter out from match
-#      (i.e. filename is not out-of-date artifact from prior Rust version/build)
-#
-# Note that a common bug is to accidentally construct the glob denoted
-# by $(2) with a space character prefix, which invalidates the
-# construction $(1)$(2).
-define CHECK_FOR_OLD_GLOB_MATCHES_EXCEPT
-  $(Q)MATCHES="$(filter-out %$(3),$(wildcard $(1)/$(2)))"; if [ -n "$$MATCHES" ] ; then echo "Warning: there are previous" \'$(2)\' "libraries:" $$MATCHES; fi
-endef
-
-# Same interface as above, but deletes rather than just listing the files.
-define REMOVE_ALL_OLD_GLOB_MATCHES_EXCEPT
-  $(Q)MATCHES="$(filter-out %$(3),$(wildcard $(1)/$(2)))"; if [ -n "$$MATCHES" ] ; then echo "Warning: removing previous" \'$(2)\' "libraries:" $$MATCHES; rm -v $$MATCHES ; fi
-endef
-
-# We use a different strategy for LIST_ALL_OLD_GLOB_MATCHES_EXCEPT
-# than in the macros above because it needs the result of running the
-# `ls` command after other rules in the command list have run; the
-# macro-expander for $(wildcard ...) would deliver its results too
-# soon. (This is in contrast to the macros above, which are meant to
-# be run at the outset of a command list in a rule.)
-ifdef VERBOSE
-define LIST_ALL_OLD_GLOB_MATCHES_EXCEPT
-  @echo "Info: now are following matches for" '$(2)' "libraries:"
-  @( cd $(1) && ( ls $(2) 2>/dev/null || true ) | grep -v $(3) || true )
-endef
-else
-define LIST_ALL_OLD_GLOB_MATCHES_EXCEPT
-endef
-endif
-
 $(foreach target,$(CFG_TARGET_TRIPLES),\
   $(eval $(call DEF_LIBS,$(target))))
 

branches/try2/configure

@@ -731,7 +731,6 @@ do
     make_dir $h/test/perf
     make_dir $h/test/pretty
     make_dir $h/test/debug-info
-    make_dir $h/test/codegen
     make_dir $h/test/doc-tutorial
     make_dir $h/test/doc-tutorial-ffi
     make_dir $h/test/doc-tutorial-macros

branches/try2/doc/rust.md

@@ -1417,83 +1417,14 @@ names are effectively reserved. Some significant attributes include:
 * The `lang` attribute, for custom definitions of traits and functions that are known to the Rust compiler (see [Language items](#language-items)).
 * The `link` attribute, for describing linkage metadata for a crate.
 * The `test` attribute, for marking functions as unit tests.
-* The `allow`, `warn`, `forbid`, and `deny` attributes, for
-  controlling lint checks (see [Lint check attributes](#lint-check-attributes)).
+* The `allow`, `warn`, `forbid`, and `deny` attributes, for controlling lint checks. Lint checks supported
+by the compiler can be found via `rustc -W help`.
 * The `deriving` attribute, for automatically generating
   implementations of certain traits.
 * The `static_assert` attribute, for asserting that a static bool is true at compiletime
 
 Other attributes may be added or removed during development of the language.
 
-### Lint check attributes
-
-A lint check names a potentially undesirable coding pattern, such as
-unreachable code or omitted documentation, for the static entity to
-which the attribute applies.
-
-For any lint check `C`:
-
- * `warn(C)` warns about violations of `C` but continues compilation,
- * `deny(C)` signals an error after encountering a violation of `C`,
- * `allow(C)` overrides the check for `C` so that violations will go
-    unreported,
- * `forbid(C)` is the same as `deny(C)`, but also forbids uses of
-   `allow(C)` within the entity.
-
-The lint checks supported by the compiler can be found via `rustc -W help`,
-along with their default settings.
-
-~~~{.xfail-test}
-mod m1 {
-    // Missing documentation is ignored here
-    #[allow(missing_doc)]
-    pub fn undocumented_one() -> int { 1 }
-
-    // Missing documentation signals a warning here
-    #[warn(missing_doc)]
-    pub fn undocumented_too() -> int { 2 }
-
-    // Missing documentation signals an error here
-    #[deny(missing_doc)]
-    pub fn undocumented_end() -> int { 3 }
-}
-~~~
-
-This example shows how one can use `allow` and `warn` to toggle
-a particular check on and off.
-
-~~~
-#[warn(missing_doc)]
-mod m2{
-    #[allow(missing_doc)]
-    mod nested {
-        // Missing documentation is ignored here
-        pub fn undocumented_one() -> int { 1 }
-
-        // Missing documentation signals a warning here,
-        // despite the allow above.
-        #[warn(missing_doc)]
-        pub fn undocumented_two() -> int { 2 }
-    }
-
-    // Missing documentation signals a warning here
-    pub fn undocumented_too() -> int { 3 }
-}
-~~~
-
-This example shows how one can use `forbid` to disallow uses
-of `allow` for that lint check.
-
-~~~{.xfail-test}
-#[forbid(missing_doc)]
-mod m3 {
-    // Attempting to toggle warning signals an error here
-    #[allow(missing_doc)]
-    /// Returns 2.
-    pub fn undocumented_too() -> int { 2 }
-}
-~~~
-
 ### Language items
 
 Some primitive Rust operations are defined in Rust code,

branches/try2/doc/tutorial-container.md

@@ -205,104 +205,3 @@ println(fmt!("last: %?", it.next()));
 // the iterator is now fully consumed
 assert!(it.next().is_none());
 ~~~
-
-## Conversion
-
-Iterators offer generic conversion to containers with the `collect` adaptor:
-
-~~~
-let xs = [0, 1, 1, 2, 3, 5, 8];
-let ys = xs.rev_iter().skip(1).transform(|&x| x * 2).collect::<~[int]>();
-assert_eq!(ys, ~[10, 6, 4, 2, 2, 0]);
-~~~
-
-The method requires a type hint for the container type, if the surrounding code
-does not provide sufficient information.
-
-Containers can provide conversion from iterators through `collect` by
-implementing the `FromIterator` trait. For example, the implementation for
-vectors is as follows:
-
-~~~
-impl<A, T: Iterator<A>> FromIterator<A, T> for ~[A] {
-    pub fn from_iterator(iterator: &mut T) -> ~[A] {
-        let (lower, _) = iterator.size_hint();
-        let mut xs = with_capacity(lower);
-        for iterator.advance |x| {
-            xs.push(x);
-        }
-        xs
-    }
-}
-~~~
-
-### Size hints
-
-The `Iterator` trait provides a `size_hint` default method, returning a lower
-bound and optionally on upper bound on the length of the iterator:
-
-~~~
-fn size_hint(&self) -> (uint, Option<uint>) { (0, None) }
-~~~
-
-The vector implementation of `FromIterator` from above uses the lower bound
-to pre-allocate enough space to hold the minimum number of elements the
-iterator will yield.
-
-The default implementation is always correct, but it should be overridden if
-the iterator can provide better information.
-
-The `ZeroStream` from earlier can provide an exact lower and upper bound:
-
-~~~
-/// A stream of N zeroes
-struct ZeroStream {
-    priv remaining: uint
-}
-
-impl ZeroStream {
-    fn new(n: uint) -> ZeroStream {
-        ZeroStream { remaining: n }
-    }
-
-    fn size_hint(&self) -> (uint, Option<uint>) {
-        (self.remaining, Some(self.remaining))
-    }
-}
-
-impl Iterator<int> for ZeroStream {
-    fn next(&mut self) -> Option<int> {
-        if self.remaining == 0 {
-            None
-        } else {
-            self.remaining -= 1;
-            Some(0)
-        }
-    }
-}
-~~~
-
-## Double-ended iterators
-
-The `DoubleEndedIterator` trait represents an iterator able to yield elements
-from either end of a range. It inherits from the `Iterator` trait and extends
-it with the `next_back` function.
-
-A `DoubleEndedIterator` can be flipped with the `invert` adaptor, returning
-another `DoubleEndedIterator` with `next` and `next_back` exchanged.
-
-~~~
-let xs = [1, 2, 3, 4, 5, 6];
-let mut it = xs.iter();
-println(fmt!("%?", it.next())); // prints `Some(&1)`
-println(fmt!("%?", it.next())); // prints `Some(&2)`
-println(fmt!("%?", it.next_back())); // prints `Some(&6)`
-
-// prints `5`, `4` and `3`
-for it.invert().advance |&x| {
-    println(fmt!("%?", x))
-}
-~~~
-
-The `rev_iter` and `mut_rev_iter` methods on vectors just return an inverted
-version of the standard immutable and mutable vector iterators.

branches/try2/man/rust.1

@@ -86,10 +86,10 @@ Build a test harness
 \fB\-\-target\fR TRIPLE
 Target triple cpu-manufacturer-kernel[-os] to compile for (see
 http://sources.redhat.com/autobook/autobook/autobook_17.html
-for details)
+for detail)
 .TP
 \fB\-\-target-feature\fR TRIPLE
-Target-specific attributes (see llc -mattr=help for details)
+Target-specific attributes (see llc -mattr=help for detail)
 .TP
 \fB\-\-android-cross-path\fR PATH
 The path to the Android NDK
@@ -128,9 +128,6 @@ To build either with a crate (.rc) file:
 To build an executable with debug info (experimental):
     $ rustc -Z debug-info -o hello hello.rs
 
-.SH "SEE ALSO"
-
-rust, rustdoc, rustpkg, rusti
 
 .SH "BUGS"
 See <\fBhttps://github.com/mozilla/rust/issues\fR> for issues.