---

yaml
---
r: 96142
b: refs/heads/dist-snap
c: 8eda5d8
h: refs/heads/master
v: v3

Author: bors

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

branches/dist-snap/doc/rust.md

@@ -254,6 +254,7 @@ 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' ;
@@ -318,8 +319,9 @@ 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 ;

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,6 +2520,11 @@ 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/url.rs

@@ -364,6 +364,16 @@ 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,
-                          "disallowed operator in constant expression");
+                          "cannot do allocations in constant expressions");
             return;
           }
           ExprLit(@codemap::Spanned {node: lit_str(*), _}) => { }
@@ -191,7 +191,13 @@ 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,20 +883,23 @@ 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), _, _) => {
-            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);
+        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");
             }
         }
         _ => ()

branches/dist-snap/src/librustc/middle/typeck/check/mod.rs

@@ -863,11 +863,13 @@ pub fn compare_impl_method(tcx: ty::ctxt,
     if impl_m.fty.sig.inputs.len() != trait_m.fty.sig.inputs.len() {
         tcx.sess.span_err(
             impl_m_span,
-            format!("method `{}` has {} parameter(s) \
-                    but the trait has {} parameter(s)",
-                    tcx.sess.str_of(trait_m.ident),
-                    impl_m.fty.sig.inputs.len(),
-                    trait_m.fty.sig.inputs.len()));
+            format!("method `{}` has {} parameter{} \
+                  but the declaration in trait `{}` has {}",
+                 tcx.sess.str_of(trait_m.ident),
+                 impl_m.fty.sig.inputs.len(),
+                 if impl_m.fty.sig.inputs.len() == 1 { "" } else { "s" },
+                 ty::item_path_str(tcx, trait_m.def_id),
+                 trait_m.fty.sig.inputs.len()));
         return;
     }
 

branches/dist-snap/src/librustpkg/api.rs

@@ -81,6 +81,11 @@ pub fn new_workcache_context(p: &Path) -> workcache::Context {
 
 pub fn build_lib(sysroot: Path, root: Path, name: ~str, version: Version,
                  lib: Path) {
+    build_lib_with_cfgs(sysroot, root, name, version, lib, ~[])
+}
+
+pub fn build_lib_with_cfgs(sysroot: Path, root: Path, name: ~str,
+                           version: Version, lib: Path, cfgs: ~[~str]) {
     let cx = default_context(sysroot, root.clone());
     let pkg_src = PkgSrc {
         source_workspace: root.clone(),
@@ -94,11 +99,16 @@ pub fn build_lib(sysroot: Path, root: Path, name: ~str, version: Version,
         tests: ~[],
         benchs: ~[]
     };
-    pkg_src.build(&cx, ~[], []);
+    pkg_src.build(&cx, cfgs, []);
 }
 
 pub fn build_exe(sysroot: Path, root: Path, name: ~str, version: Version,
                  main: Path) {
+    build_exe_with_cfgs(sysroot, root, name, version, main, ~[])
+}
+
+pub fn build_exe_with_cfgs(sysroot: Path, root: Path, name: ~str,
+                           version: Version, main: Path, cfgs: ~[~str]) {
     let cx = default_context(sysroot, root.clone());
     let pkg_src = PkgSrc {
         source_workspace: root.clone(),
@@ -113,7 +123,7 @@ pub fn build_exe(sysroot: Path, root: Path, name: ~str, version: Version,
         benchs: ~[]
     };
 
-    pkg_src.build(&cx, ~[], []);
+    pkg_src.build(&cx, cfgs, []);
 }
 
 pub fn install_pkg(cx: &BuildContext,

branches/dist-snap/src/librustpkg/context.rs

@@ -11,7 +11,7 @@
 // Context data structure used by rustpkg
 
 use extra::workcache;
-use rustc::driver::session::{OptLevel, No};
+use rustc::driver::session;
 
 use std::hashmap::HashSet;
 
@@ -88,7 +88,7 @@ pub struct RustcFlags {
     // Extra arguments to pass to rustc with the --link-args flag
     link_args: Option<~str>,
     // Optimization level. 0 = default. -O = 2.
-    optimization_level: OptLevel,
+    optimization_level: session::OptLevel,
     // True if the user passed in --save-temps
     save_temps: bool,
     // Target (defaults to rustc's default target)
@@ -224,7 +224,7 @@ impl RustcFlags {
             linker: None,
             link_args: None,
             compile_upto: Nothing,
-            optimization_level: No,
+            optimization_level: session::Default,
             save_temps: false,
             target: None,
             target_cpu: None,

branches/dist-snap/src/librustpkg/package_source.rs

@@ -28,6 +28,8 @@ use workcache_support::{digest_only_date, digest_file_with_date, crate_tag};
 use extra::workcache;
 use extra::treemap::TreeMap;
 
+use rustc::driver::session;
+
 // An enumeration of the unpacked source of a package workspace.
 // This contains a list of files found in the source workspace.
 #[deriving(Clone)]
@@ -425,6 +427,7 @@ impl PkgSrc {
                     }
                     debug!("Compiling crate {}; its output will be in {}",
                            subpath.display(), sub_dir.display());
+                    let opt: session::OptLevel = subcx.context.rustc_flags.optimization_level;
                     let result = compile_crate(&subcx,
                                                exec,
                                                &id,
@@ -433,7 +436,7 @@ impl PkgSrc {
                                                &mut (sub_deps.clone()),
                                                sub_flags,
                                                subcfgs,
-                                               false,
+                                               opt,
                                                what);
                     // XXX: result is an Option<Path>. The following code did not take that
                     // into account. I'm not sure if the workcache really likes seeing the

branches/dist-snap/src/librustpkg/util.rs

@@ -175,7 +175,7 @@ pub fn compile_input(context: &BuildContext,
                      deps: &mut DepMap,
                      flags: &[~str],
                      cfgs: &[~str],
-                     opt: bool,
+                     opt: session::OptLevel,
                      what: OutputType) -> Option<Path> {
     assert!(in_file.component_iter().nth(1).is_some());
     let input = driver::file_input(in_file.clone());
@@ -241,7 +241,7 @@ pub fn compile_input(context: &BuildContext,
 
     let options = @session::options {
         crate_type: crate_type,
-        optimize: if opt { session::Aggressive } else { session::No },
+        optimize: opt,
         test: what == Test || what == Bench,
         maybe_sysroot: Some(sysroot_to_use),
         addl_lib_search_paths: @mut context.additional_library_paths(),
@@ -408,7 +408,7 @@ pub fn compile_crate(ctxt: &BuildContext,
                      deps: &mut DepMap,
                      flags: &[~str],
                      cfgs: &[~str],
-                     opt: bool,
+                     opt: session::OptLevel,
                      what: OutputType) -> Option<Path> {
     debug!("compile_crate: crate={}, workspace={}", crate.display(), workspace.display());
     debug!("compile_crate: short_name = {}, flags =...", pkg_id.to_str());

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

@@ -207,7 +207,7 @@ mod tests {
 
     #[test]
     fn type_id_hash() {
-        let (a, b) = (TypeId::of::<uint>(), TypeId::of::<uint>::());
+        let (a, b) = (TypeId::of::<uint>(), TypeId::of::<uint>());
 
         assert_eq!(a.hash(), b.hash());
     }

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

@@ -25,14 +25,6 @@ pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
     dest
 }
 
-/**
- * Forces a copy of a value, even if that value is considered noncopyable.
- */
-#[inline]
-pub unsafe fn unsafe_copy<T>(thing: &T) -> T {
-    transmute_copy(thing)
-}
-
 /**
  * Move a thing into the void
  *