---

yaml
---
r: 142901
b: refs/heads/try2
c: 8a1002f
h: refs/heads/master
i:
  142899: 80b4427
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: 877bba91d54457c104ff0bf67fd46a499a451cf6
+refs/heads/try2: 8a1002fbd93989bbf5c8989ed8002827920b375b
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/rust.md

@@ -1417,14 +1417,83 @@ 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. Lint checks supported
-by the compiler can be found via `rustc -W help`.
+* The `allow`, `warn`, `forbid`, and `deny` attributes, for
+  controlling lint checks (see [Lint check attributes](#lint-check-attributes)).
 * 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/src/libextra/semver.rs

@@ -113,13 +113,7 @@ impl cmp::Ord for Version {
                  (0, _) => false,
                  (_, 0) => true,
                  (_, _) => self.pre < other.pre
-             })) ||
-
-            (self.major == other.major &&
-             self.minor == other.minor &&
-             self.patch == other.patch &&
-             self.pre == other.pre &&
-             self.build < other.build)
+             }))
     }
 
     #[inline]
@@ -324,6 +318,8 @@ fn test_parse() {
 fn test_eq() {
     assert_eq!(parse("1.2.3"), parse("1.2.3"));
     assert_eq!(parse("1.2.3-alpha1"), parse("1.2.3-alpha1"));
+    assert_eq!(parse("1.2.3+build.42"), parse("1.2.3+build.42"));
+    assert_eq!(parse("1.2.3-alpha1+42"), parse("1.2.3-alpha1+42"));
 }
 
 #[test]
@@ -332,6 +328,7 @@ fn test_ne() {
     assert!(parse("0.0.0")       != parse("0.1.0"));
     assert!(parse("0.0.0")       != parse("1.0.0"));
     assert!(parse("1.2.3-alpha") != parse("1.2.3-beta"));
+    assert!(parse("1.2.3+23")    != parse("1.2.3+42"));
 }
 
 #[test]
@@ -342,6 +339,7 @@ fn test_lt() {
     assert!(parse("1.2.3-alpha1") < parse("1.2.3"));
     assert!(parse("1.2.3-alpha1") < parse("1.2.3-alpha2"));
     assert!(!(parse("1.2.3-alpha2") < parse("1.2.3-alpha2")));
+    assert!(!(parse("1.2.3+23")     < parse("1.2.3+42")));
 }
 
 #[test]
@@ -351,6 +349,7 @@ fn test_le() {
     assert!(parse("1.2.0")        <= parse("1.2.3-alpha2"));
     assert!(parse("1.2.3-alpha1") <= parse("1.2.3-alpha2"));
     assert!(parse("1.2.3-alpha2") <= parse("1.2.3-alpha2"));
+    assert!(parse("1.2.3+23")     <= parse("1.2.3+42"));
 }
 
 #[test]
@@ -361,6 +360,7 @@ fn test_gt() {
     assert!(parse("1.2.3-alpha2") > parse("1.2.3-alpha1"));
     assert!(parse("1.2.3")        > parse("1.2.3-alpha2"));
     assert!(!(parse("1.2.3-alpha2") > parse("1.2.3-alpha2")));
+    assert!(!(parse("1.2.3+23")     > parse("1.2.3+42")));
 }
 
 #[test]
@@ -370,22 +370,20 @@ fn test_ge() {
     assert!(parse("1.2.3-alpha2") >= parse("1.2.0"));
     assert!(parse("1.2.3-alpha2") >= parse("1.2.3-alpha1"));
     assert!(parse("1.2.3-alpha2") >= parse("1.2.3-alpha2"));
+    assert!(parse("1.2.3+23")     >= parse("1.2.3+42"));
 }
 
 #[test]
 fn test_spec_order() {
 
     let vs = ["1.0.0-alpha",
               "1.0.0-alpha.1",
+              "1.0.0-alpha.beta",
+              "1.0.0-beta",
               "1.0.0-beta.2",
               "1.0.0-beta.11",
               "1.0.0-rc.1",
-              "1.0.0-rc.1+build.1",
-              "1.0.0",
-              "1.0.0+0.3.7",
-              "1.3.7+build",
-              "1.3.7+build.2.b8f12d7",
-              "1.3.7+build.11.e0f985a"];
+              "1.0.0"];
     let mut i = 1;
     while i < vs.len() {
         let a = parse(vs[i-1]).get();

branches/try2/src/libextra/smallintmap.rs

@@ -161,8 +161,8 @@ impl<V> SmallIntMap<V> {
     /// Visit all key-value pairs in reverse order
     pub fn each_reverse<'a>(&'a self, it: &fn(uint, &'a V) -> bool) -> bool {
         for uint::range_rev(self.v.len(), 0) |i| {
-            match self.v[i - 1] {
-              Some(ref elt) => if !it(i - 1, elt) { return false; },
+            match self.v[i] {
+              Some(ref elt) => if !it(i, elt) { return false; },
               None => ()
             }
         }

branches/try2/src/librustc/driver/driver.rs

@@ -194,6 +194,10 @@ pub fn compile_rest(sess: Session,
         //   mod bar { macro_rules! baz!(() => {{}}) }
         //
         // baz! should not use this definition unless foo is enabled.
+        crate = time(time_passes, ~"std macros injection", ||
+                     syntax::ext::expand::inject_std_macros(sess.parse_sess, copy cfg,
+                                                             crate));
+
         crate = time(time_passes, ~"configuration 1", ||
                      front::config::strip_unconfigured_items(crate));
 
@@ -214,7 +218,7 @@ pub fn compile_rest(sess: Session,
     assert!(phases.from != cu_no_trans);
 
     let (llcx, llmod, link_meta) = {
-        crate = time(time_passes, ~"extra injection", ||
+        crate = time(time_passes, ~"std injection", ||
                      front::std_inject::maybe_inject_libstd_ref(sess, crate));
 
         let ast_map = time(time_passes, ~"ast indexing", ||

branches/try2/src/librustc/middle/trans/base.rs

@@ -1530,7 +1530,7 @@ pub fn alloca_maybe_zeroed(cx: block, ty: Type, name: &str, zero: bool) -> Value
     let _icx = push_ctxt("alloca");
     if cx.unreachable {
         unsafe {
-            return llvm::LLVMGetUndef(ty.to_ref());
+            return llvm::LLVMGetUndef(ty.ptr_to().to_ref());
         }
     }
     let initcx = base::raw_block(cx.fcx, false, cx.fcx.get_llstaticallocas());

branches/try2/src/librustc/middle/trans/build.rs

@@ -569,15 +569,17 @@ pub fn LoadRangeAssert(cx: block, PointerVal: ValueRef, lo: c_ulonglong,
                        hi: c_ulonglong, signed: lib::llvm::Bool) -> ValueRef {
     let value = Load(cx, PointerVal);
 
-    unsafe {
-        let t = llvm::LLVMGetElementType(llvm::LLVMTypeOf(PointerVal));
-        let min = llvm::LLVMConstInt(t, lo, signed);
-        let max = llvm::LLVMConstInt(t, hi, signed);
-
-        do [min, max].as_imm_buf |ptr, len| {
-            llvm::LLVMSetMetadata(value, lib::llvm::MD_range as c_uint,
-                                  llvm::LLVMMDNodeInContext(cx.fcx.ccx.llcx,
-                                                            ptr, len as c_uint));
+    if !cx.unreachable {
+        unsafe {
+            let t = llvm::LLVMGetElementType(llvm::LLVMTypeOf(PointerVal));
+            let min = llvm::LLVMConstInt(t, lo, signed);
+            let max = llvm::LLVMConstInt(t, hi, signed);
+
+            do [min, max].as_imm_buf |ptr, len| {
+                llvm::LLVMSetMetadata(value, lib::llvm::MD_range as c_uint,
+                                      llvm::LLVMMDNodeInContext(cx.fcx.ccx.llcx,
+                                                                ptr, len as c_uint));
+            }
         }
     }
 

branches/try2/src/librustc/middle/trans/controlflow.rs

@@ -63,6 +63,38 @@ pub fn trans_if(bcx: block,
     let _indenter = indenter();
 
     let _icx = push_ctxt("trans_if");
+
+    match cond.node {
+        // `if true` and `if false` can be trans'd more efficiently,
+        // by dropping branches that are known to be impossible.
+        ast::expr_lit(@ref l) => match l.node {
+            ast::lit_bool(true) => {
+                // if true { .. } [else { .. }]
+                let then_bcx_in = scope_block(bcx, thn.info(), "if_true_then");
+                let then_bcx_out = trans_block(then_bcx_in, thn, dest);
+                let then_bcx_out = trans_block_cleanups(then_bcx_out,
+                                                        block_cleanups(then_bcx_in));
+                Br(bcx, then_bcx_in.llbb);
+                return then_bcx_out;
+            }
+            ast::lit_bool(false) => {
+                match els {
+                    // if false { .. } else { .. }
+                    Some(elexpr) => {
+                        let (else_bcx_in, else_bcx_out) =
+                            trans_if_else(bcx, elexpr, dest, "if_false_else");
+                        Br(bcx, else_bcx_in.llbb);
+                        return else_bcx_out;
+                    }
+                    // if false { .. }
+                    None => return bcx,
+                }
+            }
+            _ => {}
+        },
+        _ => {}
+    }
+
     let Result {bcx, val: cond_val} =
         expr::trans_to_datum(bcx, cond).to_result();
 
@@ -80,22 +112,8 @@ pub fn trans_if(bcx: block,
     // 'else' context
     let (else_bcx_in, next_bcx) = match els {
       Some(elexpr) => {
-        let else_bcx_in = scope_block(bcx, els.info(), "else");
-        let else_bcx_out = match elexpr.node {
-          ast::expr_if(_, _, _) => {
-            let elseif_blk = ast_util::block_from_expr(elexpr);
-            trans_block(else_bcx_in, &elseif_blk, dest)
-          }
-          ast::expr_block(ref blk) => {
-            trans_block(else_bcx_in, blk, dest)
-          }
-          // would be nice to have a constraint on ifs
-          _ => bcx.tcx().sess.bug("strange alternative in if")
-        };
-        let else_bcx_out = trans_block_cleanups(else_bcx_out,
-                                                block_cleanups(else_bcx_in));
-
-        (else_bcx_in, join_blocks(bcx, [then_bcx_out, else_bcx_out]))
+          let (else_bcx_in, else_bcx_out) = trans_if_else(bcx, elexpr, dest, "else");
+          (else_bcx_in, join_blocks(bcx, [then_bcx_out, else_bcx_out]))
       }
       _ => {
           let next_bcx = sub_block(bcx, "next");
@@ -109,7 +127,27 @@ pub fn trans_if(bcx: block,
            then_bcx_in.to_str(), else_bcx_in.to_str());
 
     CondBr(bcx, cond_val, then_bcx_in.llbb, else_bcx_in.llbb);
-    next_bcx
+    return next_bcx;
+
+    // trans `else [ if { .. } ... | { .. } ]`
+    fn trans_if_else(bcx: block, elexpr: @ast::expr,
+                     dest: expr::Dest, scope_name: &str) -> (block, block) {
+        let else_bcx_in = scope_block(bcx, elexpr.info(), scope_name);
+        let else_bcx_out = match elexpr.node {
+            ast::expr_if(_, _, _) => {
+                let elseif_blk = ast_util::block_from_expr(elexpr);
+                trans_block(else_bcx_in, &elseif_blk, dest)
+            }
+            ast::expr_block(ref blk) => {
+                trans_block(else_bcx_in, blk, dest)
+            }
+            // would be nice to have a constraint on ifs
+            _ => bcx.tcx().sess.bug("strange alternative in if")
+        };
+        let else_bcx_out = trans_block_cleanups(else_bcx_out,
+                                                block_cleanups(else_bcx_in));
+        (else_bcx_in, else_bcx_out)
+    }
 }
 
 pub fn join_blocks(parent_bcx: block, in_cxs: &[block]) -> block {

branches/try2/src/librustc/middle/trans/datum.rs

@@ -413,7 +413,7 @@ impl Datum {
     pub fn to_value_datum(&self, bcx: block) -> Datum {
         /*!
          *
-         * Yields a by-ref form of this datum.  This may involve
+         * Yields a by-value form of this datum.  This may involve
          * creation of a temporary stack slot.  The value returned by
          * this function is not separately rooted from this datum, so
          * it will not live longer than the current datum. */

branches/try2/src/librustdoc/astsrv.rs

@@ -113,6 +113,8 @@ fn build_ctxt(sess: Session,
 
     use rustc::front::config;
 
+    let ast = syntax::ext::expand::inject_std_macros(sess.parse_sess,
+                                                     copy sess.opts.cfg, ast);
     let ast = config::strip_unconfigured_items(ast);
     let ast = syntax::ext::expand::expand_crate(sess.parse_sess,
                                                 copy sess.opts.cfg, ast);
@@ -138,7 +140,8 @@ fn should_prune_unconfigured_items() {
     let source = ~"#[cfg(shut_up_and_leave_me_alone)]fn a() { }";
     do from_str(source) |srv| {
         do exec(srv) |ctxt| {
-            assert!(ctxt.ast.node.module.items.is_empty());
+            // one item: the __std_macros secret module
+            assert_eq!(ctxt.ast.node.module.items.len(), 1);
         }
     }
 }

branches/try2/src/librustdoc/attr_pass.rs

@@ -255,7 +255,8 @@ mod test {
     #[test]
     fn should_should_extract_mod_attributes() {
         let doc = mk_doc(~"#[doc = \"test\"] mod a { }");
-        assert!(doc.cratemod().mods()[0].desc() == Some(~"test"));
+        // hidden __std_macros module at the start.
+        assert!(doc.cratemod().mods()[1].desc() == Some(~"test"));
     }
 
     #[test]

branches/try2/src/librustdoc/desc_to_brief_pass.rs

@@ -190,7 +190,8 @@ mod test {
     #[test]
     fn should_promote_desc() {
         let doc = mk_doc(~"#[doc = \"desc\"] mod m { }");
-        assert_eq!(doc.cratemod().mods()[0].brief(), Some(~"desc"));
+        // hidden __std_macros module at the start.
+        assert_eq!(doc.cratemod().mods()[1].brief(), Some(~"desc"));
     }
 
     #[test]