---

yaml
---
r: 146910
b: refs/heads/try2
c: 79ed898
h: refs/heads/master
v: v3

Author: klutzy

[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: 68e3292fd79230f00745dc7608f4d80329c776bb
+refs/heads/try2: 79ed898f64f45cdcca6eadad3a5ad378fc8ff635
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/rust.md

@@ -153,19 +153,17 @@ Some productions are defined by exclusion of particular Unicode characters:
 ~~~~ {.ebnf .gram}
 comment : block_comment | line_comment ;
 block_comment : "/*" block_comment_body * '*' + '/' ;
-block_comment_body : (block_comment | character) * ;
+block_comment_body : non_star * | '*' + non_slash_or_star ;
 line_comment : "//" non_eol * ;
 ~~~~
 
 Comments in Rust code follow the general C++ style of line and block-comment forms,
 with no nesting of block-comment delimiters.
 
-Line comments beginning with exactly _three_ slashes (`///`), and block
-comments beginning with a exactly one repeated asterisk in the block-open
-sequence (`/**`), are interpreted as a special syntax for `doc`
-[attributes](#attributes).  That is, they are equivalent to writing
-`#[doc="..."]` around the body of the comment (this includes the comment
-characters themselves, ie `/// Foo` turns into `#[doc="/// Foo"]`).
+Line comments beginning with _three_ slashes (`///`),
+and block comments beginning with a repeated asterisk in the block-open sequence (`/**`),
+are interpreted as a special syntax for `doc` [attributes](#attributes).
+That is, they are equivalent to writing `#[doc "..."]` around the comment's text.
 
 Non-doc comments are interpreted as a form of whitespace.
 

branches/try2/src/etc/unicode.py

@@ -5,7 +5,7 @@
 # code covering the core properties. Since this is a pretty rare event we
 # just store this out-of-line and check the unicode.rs file into git.
 #
-# The emitted code is "the minimum we think is necessary for libstd", that
+# The emitted code is "the minimum we think is necessary for libcore", that
 # is, to support basic operations of the compiler and "most nontrivial rust
 # programs". It is not meant to be a complete implementation of unicode.
 # For that we recommend you use a proper binding to libicu.
@@ -41,7 +41,7 @@ def load_unicode_data(f):
             continue
         [code, name, gencat, combine, bidi,
          decomp, deci, digit, num, mirror,
-         old, iso, upcase, lowcase, titlecase ] = fields
+         old, iso, upcase, lowcsae, titlecase ] = fields
 
         code = int(code, 16)
 
@@ -89,9 +89,11 @@ def load_unicode_data(f):
 
     return (canon_decomp, compat_decomp, gencats, combines)
 
-def load_properties(f, interestingprops):
+
+def load_derived_core_properties(f):
     fetch(f)
-    props = {}
+    derivedprops = {}
+    interestingprops = ["XID_Start", "XID_Continue", "Alphabetic"]
     re1 = re.compile("^([0-9A-F]+) +; (\w+)")
     re2 = re.compile("^([0-9A-F]+)\.\.([0-9A-F]+) +; (\w+)")
 
@@ -116,10 +118,10 @@ def load_properties(f, interestingprops):
             continue
         d_lo = int(d_lo, 16)
         d_hi = int(d_hi, 16)
-        if prop not in props:
-            props[prop] = []
-        props[prop].append((d_lo, d_hi))
-    return props
+        if prop not in derivedprops:
+            derivedprops[prop] = []
+        derivedprops[prop].append((d_lo, d_hi))
+    return derivedprops
 
 def escape_char(c):
     if c <= 0xff:
@@ -142,7 +144,7 @@ def emit_bsearch_range_table(f):
         use cmp::{Equal, Less, Greater};
         use vec::ImmutableVector;
         use option::None;
-        r.bsearch(|&(lo,hi)| {
+        (do r.bsearch |&(lo,hi)| {
             if lo <= c && c <= hi { Equal }
             else if hi < c { Less }
             else { Greater }
@@ -300,14 +302,14 @@ def emit_decomp_module(f, canon, compat, combine):
         ix += 1
     f.write("\n    ];\n")
 
-    f.write("    pub fn canonical(c: char, i: |char|) "
+    f.write("    pub fn canonical(c: char, i: &fn(char)) "
         + "{ d(c, i, false); }\n\n")
-    f.write("    pub fn compatibility(c: char, i: |char|) "
+    f.write("    pub fn compatibility(c: char, i: &fn(char)) "
             +"{ d(c, i, true); }\n\n")
     f.write("    pub fn canonical_combining_class(c: char) -> u8 {\n"
         + "        bsearch_range_value_table(c, combining_class_table)\n"
         + "    }\n\n")
-    f.write("    fn d(c: char, i: |char|, k: bool) {\n")
+    f.write("    fn d(c: char, i: &fn(char), k: bool) {\n")
     f.write("        use iter::Iterator;\n");
 
     f.write("        if c <= '\\x7f' { i(c); return; }\n")
@@ -374,9 +376,5 @@ def emit_decomp_module(f, canon, compat, combine):
 
 emit_decomp_module(rf, canon_decomp, compat_decomp, combines)
 
-derived = load_properties("DerivedCoreProperties.txt",
-        ["XID_Start", "XID_Continue", "Alphabetic", "Lowercase", "Uppercase"])
+derived = load_derived_core_properties("DerivedCoreProperties.txt")
 emit_property_module(rf, "derived_property", derived)
-
-props = load_properties("PropList.txt", ["White_Space"])
-emit_property_module(rf, "property", props)

branches/try2/src/etc/vim/syntax/rust.vim

@@ -187,8 +187,8 @@ syn match   rustCharacter   /'\([^'\\]\|\\\([nrt0\\'"]\|x\x\{2}\|u\x\{4}\|U\x\{8
 
 syn region    rustCommentML   start="/\*" end="\*/" contains=rustTodo
 syn region    rustComment     start="//" end="$" contains=rustTodo keepend
-syn region    rustCommentMLDoc start="/\*\%(!\|\*[*/]\@!\)" end="\*/" contains=rustTodo
-syn region    rustCommentDoc  start="//\%(//\@!\|!\)" end="$" contains=rustTodo keepend
+syn region    rustCommentMLDoc start="/\*\%(!\|\*/\@!\)" end="\*/" contains=rustTodo
+syn region    rustCommentDoc  start="//[/!]" end="$" contains=rustTodo keepend
 
 syn keyword rustTodo contained TODO FIXME XXX NB NOTE
 

branches/try2/src/librustc/front/feature_gate.rs

@@ -18,8 +18,6 @@
 //! Features are enabled in programs via the crate-level attributes of
 //! #[feature(...)] with a comma-separated list of features.
 
-use middle::lint;
-
 use syntax::ast;
 use syntax::attr::AttrMetaMethods;
 use syntax::codemap::Span;
@@ -211,10 +209,7 @@ pub fn check_crate(sess: Session, crate: &ast::Crate) {
                                                      directive not necessary");
                         }
                         None => {
-                            sess.add_lint(lint::unknown_features,
-                                          ast::CRATE_NODE_ID,
-                                          mi.span,
-                                          ~"unknown feature");
+                            sess.span_err(mi.span, "unknown feature");
                         }
                     }
                 }

branches/try2/src/librustc/lib/llvm.rs

@@ -128,62 +128,22 @@ pub enum RealPredicate {
 
 // The LLVM TypeKind type - must stay in sync with the def of
 // LLVMTypeKind in llvm/include/llvm-c/Core.h
-#[cfg(not(stage0))]
-#[deriving(Eq)]
-#[repr(C)]
-pub enum TypeKind {
-    Void      = 0,
-    Half      = 1,
-    Float     = 2,
-    Double    = 3,
-    X86_FP80  = 4,
-    FP128     = 5,
-    PPC_FP128 = 6,
-    Label     = 7,
-    Integer   = 8,
-    Function  = 9,
-    Struct    = 10,
-    Array     = 11,
-    Pointer   = 12,
-    Vector    = 13,
-    Metadata  = 14,
-    X86_MMX   = 15,
-}
-
-// NOTE remove these after snapshot.  (See also #10308.)
-#[cfg(stage0)]
 pub type TypeKind = u32;
-#[cfg(stage0)]
 pub static Void: TypeKind      = 0;
-#[cfg(stage0)]
 pub static Half: TypeKind      = 1;
-#[cfg(stage0)]
 pub static Float: TypeKind     = 2;
-#[cfg(stage0)]
 pub static Double: TypeKind    = 3;
-#[cfg(stage0)]
 pub static X86_FP80: TypeKind  = 4;
-#[cfg(stage0)]
 pub static FP128: TypeKind     = 5;
-#[cfg(stage0)]
 pub static PPC_FP128: TypeKind = 6;
-#[cfg(stage0)]
 pub static Label: TypeKind     = 7;
-#[cfg(stage0)]
 pub static Integer: TypeKind   = 8;
-#[cfg(stage0)]
 pub static Function: TypeKind  = 9;
-#[cfg(stage0)]
 pub static Struct: TypeKind    = 10;
-#[cfg(stage0)]
 pub static Array: TypeKind     = 11;
-#[cfg(stage0)]
 pub static Pointer: TypeKind   = 12;
-#[cfg(stage0)]
 pub static Vector: TypeKind    = 13;
-#[cfg(stage0)]
 pub static Metadata: TypeKind  = 14;
-#[cfg(stage0)]
 pub static X86_MMX: TypeKind   = 15;
 
 #[repr(C)]

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

@@ -59,7 +59,6 @@ use syntax::codemap::Span;
 use syntax::codemap;
 use syntax::parse::token;
 use syntax::{ast, ast_util, visit};
-use syntax::ast_util::IdVisitingOperation;
 use syntax::visit::Visitor;
 
 #[deriving(Clone, Eq)]
@@ -78,7 +77,6 @@ pub enum lint {
     unused_unsafe,
     unsafe_block,
     attribute_usage,
-    unknown_features,
 
     managed_heap_memory,
     owned_heap_memory,
@@ -323,13 +321,6 @@ static lint_table: &'static [(&'static str, LintSpec)] = &[
         desc: "mass-change the level for lints which produce warnings",
         default: warn
     }),
-
-    ("unknown_features",
-     LintSpec {
-        lint: unknown_features,
-        desc: "unknown features found in create-level #[feature] directives",
-        default: deny,
-    }),
 ];
 
 /*
@@ -1329,7 +1320,7 @@ impl<'self> Visitor<()> for Context<'self> {
     }
 }
 
-impl<'self> IdVisitingOperation for Context<'self> {
+impl<'self> ast_util::IdVisitingOperation for Context<'self> {
     fn visit_id(&self, id: ast::NodeId) {
         match self.tcx.sess.lints.pop(&id) {
             None => {}
@@ -1365,7 +1356,6 @@ pub fn check_crate(tcx: ty::ctxt,
         cx.set_level(lint, level, CommandLine);
     }
     cx.with_lint_attrs(crate.attrs, |cx| {
-        cx.visit_id(ast::CRATE_NODE_ID);
         cx.visit_ids(|v| {
             v.visited_outermost = true;
             visit::walk_crate(v, crate, ());

branches/try2/src/librustdoc/html/format.rs

@@ -299,22 +299,20 @@ impl fmt::Default for clean::Type {
                 f.buf.write(s.as_bytes());
             }
             clean::Closure(ref decl) => {
-                f.buf.write(match decl.sigil {
-                    ast::BorrowedSigil => "&",
-                    ast::ManagedSigil => "@",
-                    ast::OwnedSigil => "~",
-                }.as_bytes());
-                match decl.region {
-                    Some(ref region) => write!(f.buf, "{} ", *region),
-                    None => {}
-                }
-                write!(f.buf, "{}{}fn{}",
+                let region = match decl.region {
+                    Some(ref region) => format!("{} ", *region),
+                    None => ~"",
+                };
+
+                write!(f.buf, "{}{}{arrow, select, yes{ -> {ret}} other{}}",
                        PuritySpace(decl.purity),
-                       match decl.onceness {
-                           ast::Once => "once ",
-                           ast::Many => "",
+                       match decl.sigil {
+                           ast::OwnedSigil => format!("proc({})", decl.decl.inputs),
+                           ast::BorrowedSigil => format!("{}|{}|", region, decl.decl.inputs),
+                           ast::ManagedSigil => format!("@{}fn({})", region, decl.decl.inputs),
                        },
-                       decl.decl);
+                       arrow = match decl.decl.output { clean::Unit => "no", _ => "yes" },
+                       ret = decl.decl.output);
                 // XXX: where are bounds and lifetimes printed?!
             }
             clean::BareFunction(ref decl) => {
@@ -374,18 +372,24 @@ impl fmt::Default for clean::Type {
 
 impl fmt::Default for clean::FnDecl {
     fn fmt(d: &clean::FnDecl, f: &mut fmt::Formatter) {
+        write!(f.buf, "({args}){arrow, select, yes{ -> {ret}} other{}}",
+               args = d.inputs,
+               arrow = match d.output { clean::Unit => "no", _ => "yes" },
+               ret = d.output);
+    }
+}
+
+impl fmt::Default for ~[clean::Argument] {
+    fn fmt(inputs: &~[clean::Argument], f: &mut fmt::Formatter) {
         let mut args = ~"";
-        for (i, input) in d.inputs.iter().enumerate() {
+        for (i, input) in inputs.iter().enumerate() {
             if i > 0 { args.push_str(", "); }
             if input.name.len() > 0 {
                 args.push_str(format!("{}: ", input.name));
             }
             args.push_str(format!("{}", input.type_));
         }
-        write!(f.buf, "({args}){arrow, select, yes{ -> {ret}} other{}}",
-               args = args,
-               arrow = match d.output { clean::Unit => "no", _ => "yes" },
-               ret = d.output);
+        f.buf.write(args.as_bytes());
     }
 }
 

branches/try2/src/libstd/ascii.rs

@@ -67,7 +67,7 @@ impl Ascii {
     /// Check if the character is a number (0-9)
     #[inline]
     pub fn is_digit(&self) -> bool {
-        self.chr >= 0x30 && self.chr <= 0x39
+        self.chr >= 0x31 && self.chr <= 0x39
     }
 
     /// Check if the character is a letter or number
@@ -85,7 +85,7 @@ impl Ascii {
     /// Check if the character is a control character
     #[inline]
     pub fn is_control(&self) -> bool {
-        self.chr < 0x20 || self.chr == 0x7F
+        self.chr <= 0x20 || self.chr == 0x7F
     }
 
     /// Checks if the character is printable (except space)
@@ -498,15 +498,6 @@ mod tests {
         assert_eq!('`'.to_ascii().to_upper().to_char(), '`');
         assert_eq!('{'.to_ascii().to_upper().to_char(), '{');
 
-        assert!('0'.to_ascii().is_digit());
-        assert!('9'.to_ascii().is_digit());
-        assert!(!'/'.to_ascii().is_digit());
-        assert!(!':'.to_ascii().is_digit());
-
-        assert!((0x1fu8).to_ascii().is_control());
-        assert!(!' '.to_ascii().is_control());
-        assert!((0x7fu8).to_ascii().is_control());
-
         assert!("banana".chars().all(|c| c.is_ascii()));
         assert!(!"ประเทศไทย中华Việt Nam".chars().all(|c| c.is_ascii()));
     }