---

yaml
---
r: 73464
b: refs/heads/dist-snap
c: c302010
h: refs/heads/master
v: v3

Author: thestinger

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
 refs/heads/incoming: b50030718cf28f2a5a81857a26b57442734fe854
-refs/heads/dist-snap: f5d4ea84f5f38c230235a2bab142bfb55d6febdc
+refs/heads/dist-snap: c302010ef0016b6e7d1d869afe489c6ff3735b7e
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/librustc/middle/trans/base.rs

@@ -1704,6 +1704,9 @@ pub fn create_llargs_for_fn_args(cx: fn_ctxt,
                         llvm::LLVMAddAttribute(llarg, lib::llvm::NoAliasAttribute as c_uint);
                     }
                 }
+                ast::ty_uniq(_) => {
+                    llvm::LLVMAddAttribute(llarg, lib::llvm::NoAliasAttribute as c_uint);
+                }
                 _ => {}
             }
 

branches/dist-snap/src/librustdoc/markdown_pass.rs

@@ -451,32 +451,16 @@ fn write_variants(
 fn write_variant(ctxt: &Ctxt, doc: doc::VariantDoc) {
     assert!(doc.sig.is_some());
     let sig = (&doc.sig).get();
-
-    // space out list items so they all end up within paragraph elements
-    ctxt.w.put_line(~"");
-
     match copy doc.desc {
         Some(desc) => {
-            ctxt.w.put_line(list_item_indent(fmt!("* `%s` - %s", sig, desc)));
+            ctxt.w.put_line(fmt!("* `%s` - %s", sig, desc));
         }
         None => {
             ctxt.w.put_line(fmt!("* `%s`", sig));
         }
     }
 }
 
-fn list_item_indent(item: &str) -> ~str {
-    let mut indented = ~[];
-    for str::each_line_any(item) |line| {
-        indented.push(line);
-    }
-
-    // separate markdown elements within `*` lists must be indented by four
-    // spaces, or they will escape the list context. indenting everything
-    // seems fine though.
-    str::connect_slices(indented, "\n    ")
-}
-
 fn write_trait(ctxt: &Ctxt, doc: doc::TraitDoc) {
     write_common(ctxt, doc.desc(), doc.sections());
     write_methods(ctxt, doc.methods);
@@ -823,9 +807,7 @@ mod test {
         assert!(str::contains(
             markdown,
             "\n\n#### Variants\n\
-             \n\
              \n* `b` - test\
-             \n\
              \n* `c` - test\n\n"));
     }
 
@@ -835,24 +817,7 @@ mod test {
         assert!(str::contains(
             markdown,
             "\n\n#### Variants\n\
-             \n\
              \n* `b`\
-             \n\
-             \n* `c`\n\n"));
-    }
-
-    #[test]
-    fn should_write_variant_list_with_indent() {
-        let markdown = render(
-            ~"enum a { #[doc = \"line 1\\n\\nline 2\"] b, c }");
-        assert!(str::contains(
-            markdown,
-            "\n\n#### Variants\n\
-             \n\
-             \n* `b` - line 1\
-             \n    \
-             \n    line 2\
-             \n\
              \n* `c`\n\n"));
     }
 
@@ -862,9 +827,7 @@ mod test {
         assert!(str::contains(
             markdown,
             "\n\n#### Variants\n\
-             \n\
              \n* `b(int)`\
-             \n\
              \n* `c(int)` - a\n\n"));
     }
 

branches/dist-snap/src/libstd/bool.rs

@@ -8,190 +8,45 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-/*!
-
-The `bool` module contains useful code to help work with boolean values.
-
-A quick summary:
-
-## Trait implementations for `bool`
-
-Implementations of the following traits:
-
-* `FromStr`
-* `Ord`
-* `TotalOrd`
-* `Eq`
-
-## Various functions to compare `bool`s
-
-All of the standard comparison functions one would expect: `and`, `eq`, `or`,
-and more.
-
-Also, a few conversion functions: `to_bit` and `to_str`.
-
-Finally, some inquries into the nature of truth: `is_true` and `is_false`.
-
-*/
+//! Boolean logic
 
 #[cfg(not(test))]
 use cmp::{Eq, Ord, TotalOrd, Ordering};
 use option::{None, Option, Some};
 use from_str::FromStr;
 
-/**
-* Negation of a boolean value.
-*
-* # Examples
-* ~~~
-* rusti> core::bool::not(true)
-* false
-* ~~~
-* rusti> core::bool::not(false)
-* true
-* ~~~
-*/
+/// Negation / inverse
 pub fn not(v: bool) -> bool { !v }
 
-/**
-* Conjunction of two boolean values.
-*
-* # Examples
-* ~~~
-* rusti> core::bool::and(true, false)
-* false
-* ~~~
-* rusti> core::bool::and(true, true)
-* true
-* ~~~
-*/
+/// Conjunction
 pub fn and(a: bool, b: bool) -> bool { a && b }
 
-/**
-* Disjunction of two boolean values.
-*
-* # Examples
-* ~~~
-* rusti> core::bool::or(true, false)
-* true
-* ~~~
-* rusti> core::bool::or(false, false)
-* false
-* ~~~
-*/
+/// Disjunction
 pub fn or(a: bool, b: bool) -> bool { a || b }
 
 /**
-* An 'exclusive or' of two boolean values.
-*
-* 'exclusive or' is identical to `or(and(a, not(b)), and(not(a), b))`.
-*
-* # Examples
-* ~~~
-* rusti> core::bool::xor(true, false)
-* true
-* ~~~
-* rusti> core::bool::xor(true, true)
-* false
-* ~~~
-*/
+ * Exclusive or
+ *
+ * Identical to `or(and(a, not(b)), and(not(a), b))`
+ */
 pub fn xor(a: bool, b: bool) -> bool { (a && !b) || (!a && b) }
 
-/**
-* Implication between two boolean values.
-*
-* Implication is often phrased as 'if a then b.'
-*
-* 'if a then b' is equivalent to `!a || b`.
-*
-* # Examples
-* ~~~
-* rusti> core::bool::implies(true, true)
-* true
-* ~~~
-* rusti> core::bool::implies(true, false)
-* false
-* ~~~
-*/
+/// Implication in the logic, i.e. from `a` follows `b`
 pub fn implies(a: bool, b: bool) -> bool { !a || b }
 
-/**
-* Equality between two boolean values.
-*
-* Two booleans are equal if they have the same value.
-*
-* # Examples
-* ~~~
-* rusti> core::bool::eq(false, true)
-* false
-* ~~~
-* rusti> core::bool::eq(false, false)
-* true
-* ~~~
-*/
+/// true if truth values `a` and `b` are indistinguishable in the logic
 pub fn eq(a: bool, b: bool) -> bool { a == b }
 
-/**
-* Non-equality between two boolean values.
-*
-* Two booleans are not equal if they have different values.
-*
-* # Examples
-* ~~~
-* rusti> core::bool::ne(false, true)
-* true
-* ~~~
-* rusti> core::bool::ne(false, false)
-* false
-* ~~~
-*/
+/// true if truth values `a` and `b` are distinguishable in the logic
 pub fn ne(a: bool, b: bool) -> bool { a != b }
 
-/**
-* Is a given boolean value true?
-*
-* # Examples
-* ~~~
-* rusti> core::bool::is_true(true)
-* true
-* ~~~
-* rusti> core::bool::is_true(false)
-* false
-* ~~~
-*/
+/// true if `v` represents truth in the logic
 pub fn is_true(v: bool) -> bool { v }
 
-/**
-* Is a given boolean value false?
-*
-* # Examples
-* ~~~
-* rusti> core::bool::is_false(false)
-* true
-* ~~~
-* rusti> core::bool::is_false(true)
-* false
-* ~~~
-*/
+/// true if `v` represents falsehood in the logic
 pub fn is_false(v: bool) -> bool { !v }
 
-/**
-* Parse a `bool` from a `str`.
-*
-* Yields an `Option<bool>`, because `str` may or may not actually be parseable.
-*
-* # Examples
-* ~~~
-* rusti> FromStr::from_str::<bool>("true")
-* Some(true)
-* ~~~
-* rusti> FromStr::from_str::<bool>("false")
-* Some(false)
-* ~~~
-* rusti> FromStr::from_str::<bool>("not even a boolean")
-* None
-* ~~~
-*/
+/// Parse logic value from `s`
 impl FromStr for bool {
     fn from_str(s: &str) -> Option<bool> {
         match s {
@@ -202,49 +57,19 @@ impl FromStr for bool {
     }
 }
 
-/**
-* Convert a `bool` to a `str`.
-*
-* # Examples
-* ~~~
-* rusti> std::bool::to_str(true)
-* "true"
-* ~~~
-* rusti> std::bool::to_str(false)
-* "false"
-* ~~~
-*/
+/// Convert `v` into a string
 pub fn to_str(v: bool) -> ~str { if v { ~"true" } else { ~"false" } }
 
 /**
-* Iterates over all truth values, passing them to the given block.
-*
-* There are no guarantees about the order values will be given.
-*
-* # Examples
-* ~~~
-* do core::bool::all_values |x: bool| {
-*     println(core::bool::to_str(x));
-* }
-* ~~~
-*/
+ * Iterates over all truth values by passing them to `blk` in an unspecified
+ * order
+ */
 pub fn all_values(blk: &fn(v: bool)) {
     blk(true);
     blk(false);
 }
 
-/**
-* Convert a `bool` to a `u8`.
-*
-* # Examples
-* ~~~
-* rusti> std::bool::to_bit(true)
-* 1
-* ~~~
-* rusti> std::bool::to_bit(false)
-* 0
-* ~~~
-*/
+/// converts truth value to an 8 bit byte
 #[inline(always)]
 pub fn to_bit(v: bool) -> u8 { if v { 1u8 } else { 0u8 } }