---

yaml
---
r: 152045
b: refs/heads/try2
c: 9051f9b
h: refs/heads/master
i:
  152043: b5aba06
v: v3

Author: Sawyer47

[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: ca287ebc645a0748869948b8217a06ecbf8afb77
+refs/heads/try2: 9051f9bc61dcca44bba56e00dc8f9b880ba29101
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/doc/tutorial.md

@@ -57,24 +57,13 @@ they don't contain references to names that aren't actually defined.
 
 # Getting started
 
-There are two ways to install the Rust compiler: by building from source or
-by downloading prebuilt binaries or installers for your platform. The
-[install page][rust-install] contains links to download binaries for both
-the nightly build and the most current Rust major release. For Windows and
-OS X, the install page provides links to native installers. 
+> *Warning:* The tarball and installer links are for the most recent
+> release, not master. To use master, you **must** build from [git].
 
-> *Note:* Windows users should read the detailed
-> [Getting started][wiki-start] notes on the wiki. Even when using
-> the binary installer, the Windows build requires a MinGW installation,
-> the precise details of which are not discussed here.
-
-For Linux and OS X, the install page provides links to binary tarballs.
-To install the Rust compiler from the from a binary tarball, download 
-the binary package, extract it, and execute the `install.sh` script in 
-the root directory of the package.
-
-To build the Rust compiler from source, you will need to obtain the source through
-[Git][git] or by downloading the source package from the [install page][rust-install].
+The Rust compiler currently must be built from a [tarball] or [git], unless
+you are on Windows, in which case using the [installer][win-exe] is
+recommended. There is a list of community-maintained nightly builds and
+packages [on the wiki][wiki-packages].
 
 Since the Rust compiler is written in Rust, it must be built by
 a precompiled "snapshot" version of itself (made in an earlier state
@@ -90,9 +79,13 @@ Snapshot binaries are currently built and tested on several platforms:
 You may find that other platforms work, but these are our "tier 1"
 supported build environments that are most likely to work.
 
+> *Note:* Windows users should read the detailed
+> [Getting started][wiki-start] notes on the wiki. Even when using
+> the binary installer, the Windows build requires a MinGW installation,
+> the precise details of which are not discussed here.
+
 [wiki-start]: https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust
 [git]: https://github.com/mozilla/rust.git
-[rust-install]: http://www.rust-lang.org/install.html
 
 To build from source you will also need the following prerequisite
 packages:

branches/try2/src/libcore/tuple.rs

@@ -9,8 +9,55 @@
 // except according to those terms.
 
 //! Operations on tuples
-
-#![allow(missing_doc)]
+//!
+//! To access a single element of a tuple one can use the following
+//! methods:
+//!
+//! * `valN` - returns a value of _N_-th element
+//! * `refN` - returns a reference to _N_-th element
+//! * `mutN` - returns a mutable reference to _N_-th element
+//!
+//! Indexing starts from zero, so `val0` returns first value, `val1`
+//! returns second value, and so on. In general, a tuple with _S_
+//! elements provides aforementioned methods suffixed with numbers
+//! from `0` to `S-1`. Traits which contain these methods are
+//! implemented for tuples with up to 12 elements.
+//!
+//! If every type inside a tuple implements one of the following
+//! traits, then a tuple itself also implements it.
+//!
+//! * `Clone`
+//! * `Eq`
+//! * `TotalEq`
+//! * `Ord`
+//! * `TotalOrd`
+//! * `Default`
+//!
+//! # Examples
+//!
+//! Using methods:
+//!
+//! ```
+//! let pair = ("pi", 3.14);
+//! assert_eq!(pair.val0(), "pi");
+//! assert_eq!(pair.val1(), 3.14);
+//! ```
+//!
+//! Using traits implemented for tuples:
+//!
+//! ```
+//! use std::default::Default;
+//!
+//! let a = (1, 2);
+//! let b = (3, 4);
+//! assert!(a != b);
+//!
+//! let c = b.clone();
+//! assert!(b == c);
+//!
+//! let d : (u32, f32) = Default::default();
+//! assert_eq!(d, (0u32, 0.0f32));
+//! ```
 
 use clone::Clone;
 #[cfg(not(test))] use cmp::*;
@@ -26,6 +73,7 @@ macro_rules! tuple_impls {
         }
     )+) => {
         $(
+            #[allow(missing_doc)]
             pub trait $Tuple<$($T),+> {
                 $(fn $valN(self) -> $T;)+
                 $(fn $refN<'a>(&'a self) -> &'a $T;)+

branches/try2/src/librustc/middle/lint.rs

@@ -72,7 +72,7 @@ use syntax::parse::token;
 use syntax::visit::Visitor;
 use syntax::{ast, ast_util, visit};
 
-#[deriving(Clone, Show, Eq, Ord, TotalEq, TotalOrd, Hash)]
+#[deriving(Clone, Eq, Ord, TotalEq, TotalOrd)]
 pub enum Lint {
     CTypes,
     UnusedImports,
@@ -94,7 +94,6 @@ pub enum Lint {
     UnknownFeatures,
     UnknownCrateType,
     UnsignedNegate,
-    VariantSizeDifference,
 
     ManagedHeapMemory,
     OwnedHeapMemory,
@@ -148,9 +147,8 @@ pub struct LintSpec {
 
 pub type LintDict = HashMap<&'static str, LintSpec>;
 
-// this is public for the lints that run in trans
 #[deriving(Eq)]
-pub enum LintSource {
+enum LintSource {
     Node(Span),
     Default,
     CommandLine
@@ -409,13 +407,6 @@ static lint_table: &'static [(&'static str, LintSpec)] = &[
         default: Warn
     }),
 
-    ("variant_size_difference",
-    LintSpec {
-        lint: VariantSizeDifference,
-        desc: "detects enums with widely varying variant sizes",
-        default: Allow,
-    }),
-
     ("unused_must_use",
     LintSpec {
         lint: UnusedMustUse,
@@ -454,78 +445,30 @@ pub fn get_lint_dict() -> LintDict {
 }
 
 struct Context<'a> {
-    /// All known lint modes (string versions)
+    // All known lint modes (string versions)
     dict: LintDict,
-    /// Current levels of each lint warning
+    // Current levels of each lint warning
     cur: SmallIntMap<(Level, LintSource)>,
-    /// Context we're checking in (used to access fields like sess)
+    // context we're checking in (used to access fields like sess)
     tcx: &'a ty::ctxt,
-    /// Items exported by the crate; used by the missing_doc lint.
+    // Items exported by the crate; used by the missing_doc lint.
     exported_items: &'a privacy::ExportedItems,
-    /// The id of the current `ast::StructDef` being walked.
+    // The id of the current `ast::StructDef` being walked.
     cur_struct_def_id: ast::NodeId,
-    /// Whether some ancestor of the current node was marked
-    /// #[doc(hidden)].
+    // Whether some ancestor of the current node was marked
+    // #[doc(hidden)].
     is_doc_hidden: bool,
 
-    /// When recursing into an attributed node of the ast which modifies lint
-    /// levels, this stack keeps track of the previous lint levels of whatever
-    /// was modified.
+    // When recursing into an attributed node of the ast which modifies lint
+    // levels, this stack keeps track of the previous lint levels of whatever
+    // was modified.
     lint_stack: Vec<(Lint, Level, LintSource)>,
 
-    /// Id of the last visited negated expression
+    // id of the last visited negated expression
     negated_expr_id: ast::NodeId,
 
-    /// Ids of structs/enums which have been checked for raw_pointer_deriving
+    // ids of structs/enums which have been checked for raw_pointer_deriving
     checked_raw_pointers: NodeSet,
-
-    /// Level of lints for certain NodeIds, stored here because the body of
-    /// the lint needs to run in trans.
-    node_levels: HashMap<(ast::NodeId, Lint), (Level, LintSource)>,
-}
-
-pub fn emit_lint(level: Level, src: LintSource, msg: &str, span: Span,
-                 lint_str: &str, tcx: &ty::ctxt) {
-    if level == Allow { return }
-
-    let mut note = None;
-    let msg = match src {
-        Default => {
-            format!("{}, \\#[{}({})] on by default", msg,
-                level_to_str(level), lint_str)
-        },
-        CommandLine => {
-            format!("{} [-{} {}]", msg,
-                match level {
-                    Warn => 'W', Deny => 'D', Forbid => 'F',
-                    Allow => fail!()
-                }, lint_str.replace("_", "-"))
-        },
-        Node(src) => {
-            note = Some(src);
-            msg.to_str()
-        }
-    };
-
-    match level {
-        Warn =>          { tcx.sess.span_warn(span, msg.as_slice()); }
-        Deny | Forbid => { tcx.sess.span_err(span, msg.as_slice());  }
-        Allow => fail!(),
-    }
-
-    for &span in note.iter() {
-        tcx.sess.span_note(span, "lint level defined here");
-    }
-}
-
-pub fn lint_to_str(lint: Lint) -> &'static str {
-    for &(name, lspec) in lint_table.iter() {
-        if lspec.lint == lint {
-            return name;
-        }
-    }
-
-    fail!("unrecognized lint: {}", lint);
 }
 
 impl<'a> Context<'a> {
@@ -557,7 +500,7 @@ impl<'a> Context<'a> {
                 return *k;
             }
         }
-        fail!("unregistered lint {}", lint);
+        fail!("unregistered lint {:?}", lint);
     }
 
     fn span_lint(&self, lint: Lint, span: Span, msg: &str) {
@@ -566,8 +509,37 @@ impl<'a> Context<'a> {
             Some(&(Warn, src)) => (self.get_level(Warnings), src),
             Some(&pair) => pair,
         };
+        if level == Allow { return }
+
+        let mut note = None;
+        let msg = match src {
+            Default => {
+                format_strbuf!("{}, \\#[{}({})] on by default",
+                               msg,
+                               level_to_str(level),
+                               self.lint_to_str(lint))
+            },
+            CommandLine => {
+                format!("{} [-{} {}]", msg,
+                    match level {
+                        Warn => 'W', Deny => 'D', Forbid => 'F',
+                        Allow => fail!()
+                    }, self.lint_to_str(lint).replace("_", "-"))
+            },
+            Node(src) => {
+                note = Some(src);
+                msg.to_str()
+            }
+        };
+        match level {
+            Warn => self.tcx.sess.span_warn(span, msg.as_slice()),
+            Deny | Forbid => self.tcx.sess.span_err(span, msg.as_slice()),
+            Allow => fail!(),
+        }
 
-        emit_lint(level, src, msg, span, self.lint_to_str(lint), self.tcx);
+        for &span in note.iter() {
+            self.tcx.sess.span_note(span, "lint level defined here");
+        }
     }
 
     /**
@@ -646,8 +618,8 @@ impl<'a> Context<'a> {
     }
 }
 
-/// Check that every lint from the list of attributes satisfies `f`.
-/// Return true if that's the case. Otherwise return false.
+// Check that every lint from the list of attributes satisfies `f`.
+// Return true if that's the case. Otherwise return false.
 pub fn each_lint(sess: &session::Session,
                  attrs: &[ast::Attribute],
                  f: |@ast::MetaItem, Level, InternedString| -> bool)
@@ -681,8 +653,8 @@ pub fn each_lint(sess: &session::Session,
     true
 }
 
-/// Check from a list of attributes if it contains the appropriate
-/// `#[level(lintname)]` attribute (e.g. `#[allow(dead_code)]).
+// Check from a list of attributes if it contains the appropriate
+// `#[level(lintname)]` attribute (e.g. `#[allow(dead_code)]).
 pub fn contains_lint(attrs: &[ast::Attribute],
                      level: Level,
                      lintname: &'static str)
@@ -1767,24 +1739,9 @@ fn check_stability(cx: &Context, e: &ast::Expr) {
     cx.span_lint(lint, e.span, msg.as_slice());
 }
 
-fn check_enum_variant_sizes(cx: &mut Context, it: &ast::Item) {
-    match it.node {
-        ast::ItemEnum(..) => {
-            match cx.cur.find(&(VariantSizeDifference as uint)) {
-                Some(&(lvl, src)) if lvl != Allow => {
-                    cx.node_levels.insert((it.id, VariantSizeDifference), (lvl, src));
-                },
-                _ => { }
-            }
-        },
-        _ => { }
-    }
-}
-
 impl<'a> Visitor<()> for Context<'a> {
     fn visit_item(&mut self, it: &ast::Item, _: ()) {
         self.with_lint_attrs(it.attrs.as_slice(), |cx| {
-            check_enum_variant_sizes(cx, it);
             check_item_ctypes(cx, it);
             check_item_non_camel_case_types(cx, it);
             check_item_non_uppercase_statics(cx, it);
@@ -1976,7 +1933,6 @@ pub fn check_crate(tcx: &ty::ctxt,
         lint_stack: Vec::new(),
         negated_expr_id: -1,
         checked_raw_pointers: NodeSet::new(),
-        node_levels: HashMap::new(),
     };
 
     // Install default lint levels, followed by the command line levels, and
@@ -2013,11 +1969,13 @@ pub fn check_crate(tcx: &ty::ctxt,
     // in the iteration code.
     for (id, v) in tcx.sess.lints.borrow().iter() {
         for &(lint, span, ref msg) in v.iter() {
-            tcx.sess.span_bug(span, format!("unprocessed lint {} at {}: {}",
-                                            lint, tcx.map.node_to_str(*id), *msg).as_slice())
+            tcx.sess.span_bug(span,
+                              format!("unprocessed lint {:?} at {}: {}",
+                                      lint,
+                                      tcx.map.node_to_str(*id),
+                                      *msg).as_slice())
         }
     }
 
     tcx.sess.abort_if_errors();
-    *tcx.node_lint_levels.borrow_mut() = cx.node_levels;
 }