---

yaml
---
r: 146908
b: refs/heads/try2
c: 26ba64d
h: refs/heads/master
v: v3

Author: g3xzh

[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: db5b51ae634830ac07b199a0842ef839d3809d8e
+refs/heads/try2: 26ba64dca9486a910a6e191d27841ebff800928c
 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/driver/session.rs

@@ -28,6 +28,7 @@ use syntax::abi;
 use syntax::parse::token;
 use syntax;
 
+use std::int;
 use std::hashmap::{HashMap,HashSet};
 
 #[deriving(Clone)]
@@ -208,7 +209,7 @@ pub struct Session_ {
     building_library: @mut bool,
     working_dir: Path,
     lints: @mut HashMap<ast::NodeId, ~[(lint::lint, codemap::Span, ~str)]>,
-    node_id: @mut ast::NodeId,
+    node_id: @mut uint,
 }
 
 pub type Session = @Session_;
@@ -273,15 +274,13 @@ impl Session_ {
     pub fn next_node_id(&self) -> ast::NodeId {
         self.reserve_node_ids(1)
     }
-    pub fn reserve_node_ids(&self, count: ast::NodeId) -> ast::NodeId {
+    pub fn reserve_node_ids(&self, count: uint) -> ast::NodeId {
         let v = *self.node_id;
-
-        match v.checked_add(&count) {
-            Some(next) => { *self.node_id = next; }
-            None => self.bug("Input too large, ran out of node ids!")
+        *self.node_id += count;
+        if v > (int::max_value as uint) {
+            self.bug("Input too large, ran out of node ids!");
         }
-
-        v
+        v as int
     }
     pub fn diagnostic(&self) -> @mut diagnostic::span_handler {
         self.span_diagnostic

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/metadata/creader.rs

@@ -67,7 +67,7 @@ impl visit::Visitor<()> for ReadCrateVisitor {
 
 #[deriving(Clone)]
 struct cache_entry {
-    cnum: ast::CrateNum,
+    cnum: int,
     span: Span,
     hash: @str,
     metas: @~[@ast::MetaItem]
@@ -242,7 +242,7 @@ fn metas_with_ident(ident: @str, metas: ~[@ast::MetaItem])
 }
 
 fn existing_match(e: &Env, metas: &[@ast::MetaItem], hash: &str)
-               -> Option<ast::CrateNum> {
+               -> Option<int> {
     for c in e.crate_cache.iter() {
         if loader::metadata_matches(*c.metas, metas)
             && (hash.is_empty() || c.hash.as_slice() == hash) {

branches/try2/src/librustc/metadata/decoder.rs

@@ -76,18 +76,18 @@ fn lookup_hash(d: ebml::Doc, eq_fn: |&[u8]| -> bool, hash: u64) ->
 
 pub type GetCrateDataCb<'self> = 'self |ast::CrateNum| -> Cmd;
 
-pub fn maybe_find_item(item_id: ast::NodeId, items: ebml::Doc) -> Option<ebml::Doc> {
-    fn eq_item(bytes: &[u8], item_id: ast::NodeId) -> bool {
+pub fn maybe_find_item(item_id: int, items: ebml::Doc) -> Option<ebml::Doc> {
+    fn eq_item(bytes: &[u8], item_id: int) -> bool {
         return u64_from_be_bytes(
-            bytes.slice(0u, 4u), 0u, 4u) as ast::NodeId
+            bytes.slice(0u, 4u), 0u, 4u) as int
             == item_id;
     }
     lookup_hash(items,
                 |a| eq_item(a, item_id),
                 (item_id as i64).hash())
 }
 
-fn find_item(item_id: ast::NodeId, items: ebml::Doc) -> ebml::Doc {
+fn find_item(item_id: int, items: ebml::Doc) -> ebml::Doc {
     match maybe_find_item(item_id, items) {
        None => fail!("lookup_item: id not found: {}", item_id),
        Some(d) => d
@@ -96,7 +96,7 @@ fn find_item(item_id: ast::NodeId, items: ebml::Doc) -> ebml::Doc {
 
 // Looks up an item in the given metadata and returns an ebml doc pointing
 // to the item data.
-pub fn lookup_item(item_id: ast::NodeId, data: @~[u8]) -> ebml::Doc {
+pub fn lookup_item(item_id: int, data: @~[u8]) -> ebml::Doc {
     let items = reader::get_doc(reader::Doc(data), tag_items);
     find_item(item_id, items)
 }
@@ -343,7 +343,7 @@ fn item_name(intr: @ident_interner, item: ebml::Doc) -> ast::Ident {
     let string = name.as_str_slice();
     match intr.find_equiv(&string) {
         None => token::str_to_ident(string),
-        Some(val) => ast::Ident::new(val as ast::Name),
+        Some(val) => ast::Ident::new(val),
     }
 }