---

yaml
---
r: 95150
b: refs/heads/dist-snap
c: 1501d65
h: refs/heads/master
v: v3

Author: Seldaek

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: b637798a5aa7878daa57c147028e98f2c5bc03c5
+refs/heads/dist-snap: 1501d6511278028f1dfe597c85141dd835f0f073
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libextra/getopts.rs

@@ -85,15 +85,13 @@ use std::vec;
 
 /// Name of an option. Either a string or a single char.
 #[deriving(Clone, Eq)]
-#[allow(missing_doc)]
 pub enum Name {
     Long(~str),
     Short(char),
 }
 
 /// Describes whether an option has an argument.
 #[deriving(Clone, Eq)]
-#[allow(missing_doc)]
 pub enum HasArg {
     Yes,
     No,
@@ -102,7 +100,6 @@ pub enum HasArg {
 
 /// Describes how often an option may occur.
 #[deriving(Clone, Eq)]
-#[allow(missing_doc)]
 pub enum Occur {
     Req,
     Optional,
@@ -144,7 +141,6 @@ pub struct Matches {
 /// The type returned when the command line does not conform to the
 /// expected format. Pass this value to <fail_str> to get an error message.
 #[deriving(Clone, Eq, ToStr)]
-#[allow(missing_doc)]
 pub enum Fail_ {
     ArgumentMissing(~str),
     UnrecognizedOption(~str),
@@ -155,7 +151,6 @@ pub enum Fail_ {
 
 /// The type of failure that occured.
 #[deriving(Eq)]
-#[allow(missing_doc)]
 pub enum FailType {
     ArgumentMissing_,
     UnrecognizedOption_,

branches/dist-snap/src/libextra/list.rs

@@ -13,14 +13,12 @@
 
 
 #[deriving(Clone, Eq)]
-#[allow(missing_doc)]
 pub enum List<T> {
     Cons(T, @List<T>),
     Nil,
 }
 
 #[deriving(Eq)]
-#[allow(missing_doc)]
 pub enum MutList<T> {
     MutCons(T, @mut MutList<T>),
     MutNil,

branches/dist-snap/src/libextra/semver.rs

@@ -38,7 +38,6 @@ use std::to_str::ToStr;
 /// An identifier in the pre-release or build metadata. If the identifier can
 /// be parsed as a decimal value, it will be represented with `Numeric`.
 #[deriving(Clone, Eq)]
-#[allow(missing_doc)]
 pub enum Identifier {
     Numeric(uint),
     AlphaNumeric(~str)

branches/dist-snap/src/libextra/terminfo/parm.rs

@@ -39,7 +39,6 @@ enum FormatState {
 
 /// Types of parameters a capability can use
 #[deriving(Clone)]
-#[allow(missing_doc)]
 pub enum Param {
     String(~str),
     Number(int)

branches/dist-snap/src/libextra/time.rs

@@ -788,6 +788,7 @@ fn do_strftime(format: &str, tm: &Tm) -> ~str {
     }
 
     fn parse_type(ch: char, tm: &Tm) -> ~str {
+        //FIXME (#2350): Implement missing types.
       let die = || format!("strftime: can't understand this format {} ", ch);
         match ch {
           'A' => match tm.tm_wday as int {
@@ -919,9 +920,10 @@ fn do_strftime(format: &str, tm: &Tm) -> ~str {
                 parse_type('b', tm),
                 parse_type('Y', tm))
           }
-          'W' => format!("{:02d}", (tm.tm_yday - (tm.tm_wday - 1 + 7) % 7 + 7)
-                         / 7),
+          //'W' {}
           'w' => (tm.tm_wday as int).to_str(),
+          //'X' {}
+          //'x' {}
           'Y' => (tm.tm_year as int + 1900).to_str(),
           'y' => format!("{:02d}", (tm.tm_year as int + 1900) % 100),
           'Z' => tm.tm_zone.clone(),
@@ -932,7 +934,7 @@ fn do_strftime(format: &str, tm: &Tm) -> ~str {
             m -= h * 60_i32;
             format!("{}{:02d}{:02d}", sign, h, m)
           }
-          '+' => tm.rfc3339(),
+          //'+' {}
           '%' => ~"%",
           _   => die()
         }
@@ -1295,13 +1297,12 @@ mod tests {
         assert_eq!(local.strftime("%u"), ~"5");
         assert_eq!(local.strftime("%V"), ~"07");
         assert_eq!(local.strftime("%v"), ~"13-Feb-2009");
-        assert_eq!(local.strftime("%W"), ~"06");
+        // assert!(local.strftime("%W") == "06");
         assert_eq!(local.strftime("%w"), ~"5");
-        assert_eq!(local.strftime("%X"), ~"15:31:30"); // FIXME (#2350): support locale
-        assert_eq!(local.strftime("%x"), ~"02/13/09"); // FIXME (#2350): support locale
+        // handle "%X"
+        // handle "%x"
         assert_eq!(local.strftime("%Y"), ~"2009");
         assert_eq!(local.strftime("%y"), ~"09");
-        assert_eq!(local.strftime("%+"), ~"2009-02-13T15:31:30-08:00");
 
         // FIXME (#2350): We should probably standardize on the timezone
         // abbreviation.

branches/dist-snap/src/libextra/uuid.rs

@@ -116,7 +116,6 @@ struct UuidFields {
 }
 
 /// Error details for string parsing failures
-#[allow(missing_doc)]
 pub enum ParseError {
     ErrorInvalidLength(uint),
     ErrorInvalidCharacter(char, uint),

branches/dist-snap/src/librustc/middle/lint.rs

@@ -1351,18 +1351,6 @@ impl MissingDocLintVisitor {
         // otherwise, warn!
         cx.span_lint(missing_doc, sp, msg);
     }
-
-    fn check_struct(&mut self, cx: @mut Context, sdef: @ast::struct_def) {
-                        for field in sdef.fields.iter() {
-        match field.node.kind {
-            ast::named_field(_, vis) if vis != ast::private => {
-                self.check_attrs(cx, field.node.attrs, field.span,
-                        "missing documentation for a field");
-                }
-                ast::unnamed_field | ast::named_field(*) => {}
-            }
-        }
-    }
 }
 
 impl Visitor<@mut Context> for MissingDocLintVisitor {
@@ -1407,49 +1395,35 @@ impl SubitemStoppableVisitor for MissingDocLintVisitor {
     }
 
     fn visit_item_action(&mut self, it:@ast::item, cx:@mut Context) {
-            if it.vis != ast::public {
-                return;
-            }
 
             match it.node {
                 // Go ahead and match the fields here instead of using
                 // visit_struct_field while we have access to the enclosing
                 // struct's visibility
-                ast::item_struct(sdef, _) => {
+                ast::item_struct(sdef, _) if it.vis == ast::public => {
                     self.check_attrs(cx, it.attrs, it.span,
                                 "missing documentation for a struct");
-                    self.check_struct(cx, sdef);
+                    for field in sdef.fields.iter() {
+                        match field.node.kind {
+                            ast::named_field(_, vis) if vis != ast::private => {
+                                self.check_attrs(cx, field.node.attrs, field.span,
+                                            "missing documentation for a field");
+                            }
+                            ast::unnamed_field | ast::named_field(*) => {}
+                        }
+                    }
                 }
 
-                ast::item_trait(*) => {
+                ast::item_trait(*) if it.vis == ast::public => {
                     self.check_attrs(cx, it.attrs, it.span,
                                 "missing documentation for a trait");
                 }
 
-                ast::item_fn(*) => {
+                ast::item_fn(*) if it.vis == ast::public => {
                     self.check_attrs(cx, it.attrs, it.span,
                                 "missing documentation for a function");
                 }
 
-                ast::item_enum(ref edef, _) => {
-                    self.check_attrs(cx, it.attrs, it.span,
-                                "missing documentation for an enum");
-                    for variant in edef.variants.iter() {
-                        if variant.node.vis == ast::private {
-                            continue;
-                        }
-
-                        self.check_attrs(cx, variant.node.attrs, variant.span,
-                                        "missing documentation for a variant");
-                        match variant.node.kind {
-                            ast::struct_variant_kind(sdef) => {
-                                self.check_struct(cx, sdef);
-                            }
-                            _ => ()
-                        }
-                    }
-                }
-
                 _ => {}
             }
     }

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

@@ -65,7 +65,7 @@ pub fn trans_intrinsic(ccx: @mut CrateContext,
         let val = Call(bcx, llfn, [a, b], []);
         let result = ExtractValue(bcx, val, 0);
         let overflow = ZExt(bcx, ExtractValue(bcx, val, 1), Type::bool());
-        let ret = C_undef(type_of::type_of(bcx.ccx(), t));
+        let ret = Load(bcx, Alloca(bcx, type_of::type_of(bcx.ccx(), t), ""));
         let ret = InsertValue(bcx, ret, result, 0);
         let ret = InsertValue(bcx, ret, overflow, 1);
 

branches/dist-snap/src/librustdoc/html/static/main.css

@@ -121,6 +121,9 @@ body {
 
 .content pre.line-numbers { float: left; border: none; }
 .line-numbers span { color: #c67e2d; }
+.line-numbers .line-highlighted {
+    background-color: #fff871;
+}
 
 .content .highlighted {
     cursor: pointer;

branches/dist-snap/src/librustdoc/html/static/main.js

@@ -31,6 +31,25 @@
     resizeShortBlocks();
     $(window).on('resize', resizeShortBlocks);
 
+    function highlightSourceLines() {
+        var i, from, to, match = window.location.hash.match(/^#?(\d+)(?:-(\d+))?$/);
+        if (match) {
+            from = parseInt(match[1], 10);
+            to = Math.min(50000, parseInt(match[2] || match[1], 10));
+            from = Math.min(from, to);
+            if ($('#' + from).length === 0) {
+                return;
+            }
+            $('#' + from)[0].scrollIntoView();
+            $('.line-numbers span').removeClass('line-highlighted');
+            for (i = from; i <= to; i += 1) {
+                $('#' + i).addClass('line-highlighted');
+            }
+        }
+    }
+    highlightSourceLines();
+    $(window).on('hashchange', highlightSourceLines);
+
     $(document).on('keyup', function (e) {
         if (document.activeElement.tagName === 'INPUT') {
             return;

branches/dist-snap/src/libstd/fmt/parse.rs

@@ -61,20 +61,17 @@ pub struct FormatSpec<'self> {
 
 /// Enum describing where an argument for a format can be located.
 #[deriving(Eq)]
-#[allow(missing_doc)]
 pub enum Position<'self> {
     ArgumentNext, ArgumentIs(uint), ArgumentNamed(&'self str)
 }
 
 /// Enum of alignments which are supported.
 #[deriving(Eq)]
-#[allow(missing_doc)]
 pub enum Alignment { AlignLeft, AlignRight, AlignUnknown }
 
 /// Various flags which can be applied to format strings, the meaning of these
 /// flags is defined by the formatters themselves.
 #[deriving(Eq)]
-#[allow(missing_doc)]
 pub enum Flag {
     FlagSignPlus,
     FlagSignMinus,
@@ -85,7 +82,6 @@ pub enum Flag {
 /// A count is used for the precision and width parameters of an integer, and
 /// can reference either an argument or a literal integer.
 #[deriving(Eq)]
-#[allow(missing_doc)]
 pub enum Count {
     CountIs(uint),
     CountIsParam(uint),
@@ -130,7 +126,6 @@ pub struct PluralArm<'self> {
 ///
 /// http://www.icu-project.org/apiref/icu4c/classicu_1_1PluralRules.html
 #[deriving(Eq, IterBytes)]
-#[allow(missing_doc)]
 pub enum PluralKeyword {
     Zero, One, Two, Few, Many
 }

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

@@ -59,7 +59,6 @@ use util;
  */
 pub type Key<T> = &'static KeyValue<T>;
 
-#[allow(missing_doc)]
 pub enum KeyValue<T> { Key }
 
 trait LocalData {}

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

@@ -56,7 +56,6 @@ use clone::DeepClone;
 
 /// The option type
 #[deriving(Clone, DeepClone, Eq)]
-#[allow(missing_doc)]
 pub enum Option<T> {
     None,
     Some(T),

branches/dist-snap/src/libstd/rt/io/native/file.rs

@@ -17,9 +17,8 @@ use libc::{c_int, FILE};
 #[allow(non_camel_case_types)]
 pub type fd_t = c_int;
 
-pub struct FileDesc {
-    priv fd: fd_t
-}
+// Make this a newtype so we can't do I/O on arbitrary integers
+pub struct FileDesc(fd_t);
 
 impl FileDesc {
     /// Create a `FileDesc` from an open C file descriptor.
@@ -47,9 +46,7 @@ impl Seek for FileDesc {
     fn seek(&mut self, _pos: i64, _style: SeekStyle) { fail2!() }
 }
 
-pub struct CFile {
-    priv file: *FILE
-}
+pub struct CFile(*FILE);
 
 impl CFile {
     /// Create a `CFile` from an open `FILE` pointer.