---

yaml
---
r: 96143
b: refs/heads/dist-snap
c: 8e59c5d
h: refs/heads/master
i:
  96141: 39b4cc2
  96139: 9647bf8
  96135: 3723164
  96127: d68cdc4
v: v3

Author: chris-morgan

[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: 8eda5d831591e608b7de2910469a73d1dc02da42
+refs/heads/dist-snap: 8e59c5d34a19e7ce58fec377f3033296476c5e92
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/doc/rust.md

@@ -254,7 +254,6 @@ common_escape : '\x5c'
 hex_digit : 'a' | 'b' | 'c' | 'd' | 'e' | 'f'
           | 'A' | 'B' | 'C' | 'D' | 'E' | 'F'
           | dec_digit ;
-oct_digit : '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' ;
 dec_digit : '0' | nonzero_dec ;
 nonzero_dec: '1' | '2' | '3' | '4'
            | '5' | '6' | '7' | '8' | '9' ;
@@ -319,9 +318,8 @@ r##"foo #"# bar"##;                // foo #"# bar
 ~~~~ {.ebnf .gram}
 
 num_lit : nonzero_dec [ dec_digit | '_' ] * num_suffix ?
-        | '0' [       [ dec_digit | '_' ] * num_suffix ?
+        | '0' [       [ dec_digit | '_' ] + num_suffix ?
               | 'b'   [ '1' | '0' | '_' ] + int_suffix ?
-              | 'o'   [ oct_digit | '_' ] + int_suffix ?
               | 'x'   [ hex_digit | '_' ] + int_suffix ? ] ;
 
 num_suffix : int_suffix | float_suffix ;
@@ -1550,7 +1548,6 @@ keyword for struct fields and enum variants). When an item is declared as `pub`,
 it can be thought of as being accessible to the outside world. For example:
 
 ~~~~
-# fn main() {}
 // Declare a private struct
 struct Foo;
 

branches/dist-snap/doc/tutorial-container.md

@@ -87,7 +87,6 @@ Reaching the end of the iterator is signalled by returning `None` instead of
 `Some(item)`:
 
 ~~~
-# fn main() {}
 /// A stream of N zeroes
 struct ZeroStream {
     priv remaining: uint
@@ -302,7 +301,6 @@ the iterator can provide better information.
 The `ZeroStream` from earlier can provide an exact lower and upper bound:
 
 ~~~
-# fn main() {}
 /// A stream of N zeroes
 struct ZeroStream {
     priv remaining: uint

branches/dist-snap/doc/tutorial-macros.md

@@ -216,7 +216,7 @@ Now consider code like the following:
 
 ~~~~
 # enum t1 { good_1(t2, uint), bad_1 };
-# struct t2 { body: t3 }
+# pub struct t2 { body: t3 }
 # enum t3 { good_2(uint), bad_2};
 # fn f(x: t1) -> uint {
 match x {
@@ -262,7 +262,7 @@ macro_rules! biased_match (
 )
 
 # enum t1 { good_1(t2, uint), bad_1 };
-# struct t2 { body: t3 }
+# pub struct t2 { body: t3 }
 # enum t3 { good_2(uint), bad_2};
 # fn f(x: t1) -> uint {
 biased_match!((x)       ~ (good_1(g1, val)) else { return 0 };
@@ -364,7 +364,7 @@ macro_rules! biased_match (
 
 
 # enum t1 { good_1(t2, uint), bad_1 };
-# struct t2 { body: t3 }
+# pub struct t2 { body: t3 }
 # enum t3 { good_2(uint), bad_2};
 # fn f(x: t1) -> uint {
 biased_match!(

branches/dist-snap/doc/tutorial.md

@@ -2568,7 +2568,6 @@ pub fn foo() { bar(); }
 ~~~
 // c.rs
 pub fn bar() { println("Baz!"); }
-# fn main() {}
 ~~~
 
 There also exist two short forms for importing multiple names at once:
@@ -2744,7 +2743,7 @@ Therefore, if you plan to compile your crate as a library, you should annotate i
 #[link(name = "farm", vers = "2.5")];
 
 // ...
-# fn farm() {}
+# pub fn farm() {}
 ~~~~
 
 You can also in turn require in a `extern mod` statement that certain link metadata items match some criteria.
@@ -2770,7 +2769,7 @@ or setting the crate type (library or executable) explicitly:
 
 // Turn on a warning
 #[warn(non_camel_case_types)]
-# fn farm() {}
+# pub fn farm() {}
 ~~~~
 
 If you're compiling your crate with `rustpkg`,
@@ -2791,9 +2790,7 @@ We define two crates, and use one of them as a library in the other.
 ~~~~
 // world.rs
 #[link(name = "world", vers = "0.42")];
-# extern mod extra;
 pub fn explore() -> &'static str { "world" }
-# fn main() {}
 ~~~~
 
 ~~~~ {.xfail-test}

branches/dist-snap/mk/ctags.mk

@@ -15,7 +15,27 @@
 
 .PHONY: TAGS.emacs TAGS.vi
 
-CTAGS_OPTS=--options=${CFG_SRC_DIR}/src/etc/ctags.rust -R ${CFG_SRC_DIR}/src
+# This is using a blacklist approach, probably more durable than a whitelist.
+# We exclude: external dependencies (llvm, libuv, gyp, rt/{msvc,sundown,vg}),
+# tests (compiletest, test) and a couple of other things (rt/arch, etc)
+CTAGS_LOCATIONS=$(patsubst ${CFG_SRC_DIR}src/llvm,,\
+				$(patsubst ${CFG_SRC_DIR}src/libuv,,\
+				$(patsubst ${CFG_SRC_DIR}src/compiletest,,\
+				$(patsubst ${CFG_SRC_DIR}src/test,,\
+				$(patsubst ${CFG_SRC_DIR}src/gyp,,\
+				$(patsubst ${CFG_SRC_DIR}src/etc,,\
+				$(patsubst ${CFG_SRC_DIR}src/rt,,\
+				$(patsubst ${CFG_SRC_DIR}src/rt/arch,,\
+				$(patsubst ${CFG_SRC_DIR}src/rt/msvc,,\
+				$(patsubst ${CFG_SRC_DIR}src/rt/sundown,,\
+				$(patsubst ${CFG_SRC_DIR}src/rt/vg,,\
+				$(wildcard ${CFG_SRC_DIR}src/*) $(wildcard ${CFG_SRC_DIR}src/rt/*)\
+				)))))))))))
+CTAGS_OPTS=--options="${CFG_SRC_DIR}src/etc/ctags.rust" --languages=-javascript --recurse ${CTAGS_LOCATIONS}
+# We could use `--languages=Rust`, but there is value in producing tags for the
+# C++ parts of the code base too (at the time of writing, those are .h and .cpp
+# files in src/rt, src/rt/sync and src/rustllvm); we mainly just want to
+# exclude the external dependencies.
 
 TAGS.emacs:
 	ctags -e -f $@ ${CTAGS_OPTS}

branches/dist-snap/src/libextra/num/bigint.rs

@@ -660,7 +660,7 @@ impl ToStrRadix for BigUint {
             let divider    = FromPrimitive::from_uint(base).unwrap();
             let mut result = ~[];
             let mut m      = n;
-            while m >= divider {
+            while m > divider {
                 let (d, m0) = m.div_mod_floor(&divider);
                 result.push(m0.to_uint().unwrap() as BigDigit);
                 m = d;
@@ -2520,11 +2520,6 @@ mod bigint_tests {
         check("-10", Some(-10));
         check("Z", None);
         check("_", None);
-
-        // issue 10522, this hit an edge case that caused it to
-        // attempt to allocate a vector of size (-1u) == huge.
-        let x: BigInt = from_str("1" + "0".repeat(36)).unwrap();
-        let _y = x.to_str();
     }
 
     #[test]

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

@@ -846,7 +846,7 @@ mod tests {
 
     fn check_sort(v1: &[int], v2: &[int]) {
         let len = v1.len();
-        fn le(a: &int, b: &int) -> bool { *a <= *b }
+        pub fn le(a: &int, b: &int) -> bool { *a <= *b }
         let f = le;
         let v3 = merge_sort::<int>(v1, f);
         let mut i = 0u;
@@ -876,7 +876,7 @@ mod tests {
 
     #[test]
     fn test_merge_sort_mutable() {
-        fn le(a: &int, b: &int) -> bool { *a <= *b }
+        pub fn le(a: &int, b: &int) -> bool { *a <= *b }
         let v1 = ~[3, 2, 1];
         let v2 = merge_sort(v1, le);
         assert_eq!(v2, ~[1, 2, 3]);

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

@@ -364,16 +364,6 @@ fn query_from_str(rawquery: &str) -> Query {
     return query;
 }
 
-/**
- * Converts an instance of a URI `Query` type to a string.
- *
- * # Example
- *
- * ```rust
- * let query = ~[(~"title", ~"The Village"), (~"north", ~"52.91"), (~"west", ~"4.10")];
- * println(query_to_str(&query));  // title=The%20Village&north=52.91&west=4.10
- * ```
- */
 pub fn query_to_str(query: &Query) -> ~str {
     let mut strvec = ~[];
     for kv in query.iter() {

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

@@ -117,7 +117,7 @@ pub fn check_expr(v: &mut CheckCrateVisitor,
           ExprUnary(_, UnDeref, _) => { }
           ExprUnary(_, UnBox(_), _) | ExprUnary(_, UnUniq, _) => {
             sess.span_err(e.span,
-                          "cannot do allocations in constant expressions");
+                          "disallowed operator in constant expression");
             return;
           }
           ExprLit(@codemap::Spanned {node: lit_str(*), _}) => { }
@@ -191,13 +191,7 @@ pub fn check_expr(v: &mut CheckCrateVisitor,
                     e.span,
                     "borrowed pointers in constants may only refer to \
                      immutable values");
-          },
-          ExprVstore(_, ExprVstoreUniq) |
-          ExprVstore(_, ExprVstoreBox) |
-          ExprVstore(_, ExprVstoreMutBox) => {
-              sess.span_err(e.span, "cannot allocate vectors in constant expressions")
-          },
-
+          }
           _ => {
             sess.span_err(e.span,
                           "constant contains unimplemented expression type");

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

@@ -883,23 +883,20 @@ fn check_unused_unsafe(cx: &Context, e: &ast::Expr) {
 
 fn check_unused_mut_pat(cx: &Context, p: @ast::Pat) {
     match p.node {
-        ast::PatIdent(ast::BindByValue(ast::MutMutable),
-                      ref path, _) if pat_util::pat_is_binding(cx.tcx.def_map, p)=> {
-            // `let mut _a = 1;` doesn't need a warning.
-            let initial_underscore = match path.segments {
-                [ast::PathSegment { identifier: id, _ }] => {
-                    cx.tcx.sess.str_of(id).starts_with("_")
-                }
-                _ => {
-                    cx.tcx.sess.span_bug(p.span,
-                                         "mutable binding that doesn't \
-                                         consist of exactly one segment");
-                }
-            };
-
-            if !initial_underscore && !cx.tcx.used_mut_nodes.contains(&p.id) {
-                cx.span_lint(unused_mut, p.span,
-                             "variable does not need to be mutable");
+        ast::PatIdent(ast::BindByValue(ast::MutMutable), _, _) => {
+            let mut used = false;
+            let mut bindings = 0;
+            do pat_util::pat_bindings(cx.tcx.def_map, p) |_, id, _, _| {
+                used = used || cx.tcx.used_mut_nodes.contains(&id);
+                bindings += 1;
+            }
+            if !used {
+                let msg = if bindings == 1 {
+                    "variable does not need to be mutable"
+                } else {
+                    "variables do not need to be mutable"
+                };
+                cx.span_lint(unused_mut, p.span, msg);
             }
         }
         _ => ()

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

@@ -13,7 +13,6 @@
 //! which are available for use externally when compiled as a library.
 
 use std::hashmap::{HashSet, HashMap};
-use std::util;
 
 use middle::resolve;
 use middle::ty;
@@ -276,7 +275,6 @@ impl<'self> Visitor<()> for EmbargoVisitor<'self> {
 struct PrivacyVisitor<'self> {
     tcx: ty::ctxt,
     curitem: ast::NodeId,
-    in_fn: bool,
 
     // See comments on the same field in `EmbargoVisitor`.
     path_all_public_items: &'self ExportedItems,
@@ -690,63 +688,6 @@ impl<'self> PrivacyVisitor<'self> {
             }
         }
     }
-
-    /// When inside of something like a function or a method, visibility has no
-    /// control over anything so this forbids any mention of any visibility
-    fn check_all_inherited(&self, item: @ast::item) {
-        let tcx = self.tcx;
-        let check_inherited = |sp: Span, vis: ast::visibility| {
-            if vis != ast::inherited {
-                tcx.sess.span_err(sp, "visibility has no effect inside functions");
-            }
-        };
-        let check_struct = |def: &@ast::struct_def| {
-            for f in def.fields.iter() {
-               match f.node.kind {
-                    ast::named_field(_, p) => check_inherited(f.span, p),
-                    ast::unnamed_field => {}
-                }
-            }
-        };
-        check_inherited(item.span, item.vis);
-        match item.node {
-            ast::item_impl(_, _, _, ref methods) => {
-                for m in methods.iter() {
-                    check_inherited(m.span, m.vis);
-                }
-            }
-            ast::item_foreign_mod(ref fm) => {
-                for i in fm.items.iter() {
-                    check_inherited(i.span, i.vis);
-                }
-            }
-            ast::item_enum(ref def, _) => {
-                for v in def.variants.iter() {
-                    check_inherited(v.span, v.node.vis);
-
-                    match v.node.kind {
-                        ast::struct_variant_kind(ref s) => check_struct(s),
-                        ast::tuple_variant_kind(*) => {}
-                    }
-                }
-            }
-
-            ast::item_struct(ref def, _) => check_struct(def),
-
-            ast::item_trait(_, _, ref methods) => {
-                for m in methods.iter() {
-                    match *m {
-                        ast::required(*) => {}
-                        ast::provided(ref m) => check_inherited(m.span, m.vis),
-                    }
-                }
-            }
-
-            ast::item_static(*) |
-            ast::item_fn(*) | ast::item_mod(*) | ast::item_ty(*) |
-            ast::item_mac(*) => {}
-        }
-    }
 }
 
 impl<'self> Visitor<()> for PrivacyVisitor<'self> {
@@ -758,28 +699,12 @@ impl<'self> Visitor<()> for PrivacyVisitor<'self> {
         }
 
         // Disallow unnecessary visibility qualifiers
-        if self.in_fn {
-            self.check_all_inherited(item);
-        } else {
-            self.check_sane_privacy(item);
-        }
+        self.check_sane_privacy(item);
 
-        let orig_curitem = util::replace(&mut self.curitem, item.id);
-        let orig_in_fn = util::replace(&mut self.in_fn, match item.node {
-            ast::item_mod(*) => false, // modules turn privacy back on
-            _ => self.in_fn,           // otherwise we inherit
-        });
+        let orig_curitem = self.curitem;
+        self.curitem = item.id;
         visit::walk_item(self, item, ());
         self.curitem = orig_curitem;
-        self.in_fn = orig_in_fn;
-    }
-
-    fn visit_fn(&mut self, fk: &visit::fn_kind, fd: &ast::fn_decl,
-                b: &ast::Block, s: Span, n: ast::NodeId, _: ()) {
-        // This catches both functions and methods
-        let orig_in_fn = util::replace(&mut self.in_fn, true);
-        visit::walk_fn(self, fk, fd, b, s, n, ());
-        self.in_fn = orig_in_fn;
     }
 
     fn visit_expr(&mut self, expr: @ast::Expr, _: ()) {
@@ -982,7 +907,6 @@ pub fn check_crate(tcx: ty::ctxt,
     {
         let mut visitor = PrivacyVisitor {
             curitem: ast::DUMMY_NODE_ID,
-            in_fn: false,
             tcx: tcx,
             path_all_public_items: &path_all_public_items,
             parents: &parents,

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

@@ -1409,7 +1409,7 @@ pub fn subst_tps(tcx: ctxt, tps: &[t], self_ty_opt: Option<t>, typ: t) -> t {
     let mut subst = TpsSubst { tcx: tcx, self_ty_opt: self_ty_opt, tps: tps };
     return subst.fold_ty(typ);
 
-    struct TpsSubst<'self> {
+    pub struct TpsSubst<'self> {
         tcx: ctxt,
         self_ty_opt: Option<t>,
         tps: &'self [t],