---

yaml
---
r: 95544
b: refs/heads/dist-snap
c: 8a60caa
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: 22465e9561293752c195e32f85644a6b141850d3
+refs/heads/dist-snap: 8a60caa107b7a55f480ae60a5184bd2e2a6319e7
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/driver/driver.rs

@@ -14,12 +14,6 @@ extern mod this(name = "rustpkg");
 #[cfg(rustdoc)]
 extern mod this(name = "rustdoc");
 
-#[cfg(rusti)]
-extern mod this(name = "rusti");
-
-#[cfg(rust)]
-extern mod this(name = "rust");
-
 #[cfg(rustc)]
 extern mod this(name = "rustc");
 

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

@@ -39,32 +39,32 @@ pub struct GlobIterator {
     priv todo: ~[(Path,uint)]
 }
 
-/**
- * Return an iterator that produces all the Paths that match the given pattern,
- * which may be absolute or relative to the current working directory.
- *
- * This method uses the default match options and is equivalent to calling
- * `glob_with(pattern, MatchOptions::new())`. Use `glob_with` directly if you
- * want to use non-default match options.
- *
- * # Example
- *
- * Consider a directory `/media/pictures` containing only the files `kittens.jpg`,
- * `puppies.jpg` and `hamsters.gif`:
- *
- * ```rust
- * for path in glob("/media/pictures/*.jpg") {
- *     println(path.to_str());
- * }
- * ```
- *
- * The above code will print:
- *
- * ```
- * /media/pictures/kittens.jpg
- * /media/pictures/puppies.jpg
- * ```
- */
+///
+/// Return an iterator that produces all the Paths that match the given pattern,
+/// which may be absolute or relative to the current working directory.
+///
+/// is method uses the default match options and is equivalent to calling
+/// `glob_with(pattern, MatchOptions::new())`. Use `glob_with` directly if you
+/// want to use non-default match options.
+///
+/// # Example
+///
+/// Consider a directory `/media/pictures` containing only the files `kittens.jpg`,
+/// `puppies.jpg` and `hamsters.gif`:
+///
+/// ```rust
+/// for path in glob("/media/pictures/*.jpg") {
+///     println(path.to_str());
+/// }
+/// ```
+///
+/// The above code will print:
+///
+/// ```
+/// /media/pictures/kittens.jpg
+/// /media/pictures/puppies.jpg
+/// ```
+///
 pub fn glob(pattern: &str) -> GlobIterator {
     glob_with(pattern, MatchOptions::new())
 }

branches/dist-snap/src/librustc/back/link.rs

@@ -297,7 +297,7 @@ pub mod write {
             if !sess.no_prepopulate_passes() {
                 llvm::LLVMRustAddAnalysisPasses(tm, fpm, llmod);
                 llvm::LLVMRustAddAnalysisPasses(tm, mpm, llmod);
-                populate_llvm_passess(fpm, mpm, llmod, OptLevel);
+                populate_llvm_passes(fpm, mpm, llmod, OptLevel);
             }
 
             for pass in sess.opts.custom_passes.iter() {
@@ -422,10 +422,10 @@ pub mod write {
         }
     }
 
-    unsafe fn populate_llvm_passess(fpm: lib::llvm::PassManagerRef,
-                                    mpm: lib::llvm::PassManagerRef,
-                                    llmod: ModuleRef,
-                                    opt: lib::llvm::CodeGenOptLevel) {
+    unsafe fn populate_llvm_passes(fpm: lib::llvm::PassManagerRef,
+                                   mpm: lib::llvm::PassManagerRef,
+                                   llmod: ModuleRef,
+                                   opt: lib::llvm::CodeGenOptLevel) {
         // Create the PassManagerBuilder for LLVM. We configure it with
         // reasonable defaults and prepare it to actually populate the pass
         // manager.

branches/dist-snap/src/librustc/front/feature_gate.rs

@@ -34,6 +34,7 @@ static KNOWN_FEATURES: &'static [(&'static str, Status)] = &[
     ("macro_rules", Active),
     ("struct_variant", Active),
     ("once_fns", Active),
+    ("asm", Active),
 
     // These are used to test this portion of the compiler, they don't actually
     // mean anything
@@ -108,26 +109,29 @@ impl Visitor<()> for Context {
                 }
             }
 
-            ast::item_mac(ref mac) => {
-                match mac.node {
-                    ast::mac_invoc_tt(ref path, _, _) => {
-                        let rules = self.sess.ident_of("macro_rules");
-                        if path.segments.last().identifier == rules {
-                            self.gate_feature("macro_rules", i.span,
-                                              "macro definitions are not \
-                                               stable enough for use and are \
-                                               subject to change");
-                        }
-                    }
-                }
-            }
-
             _ => {}
         }
 
         visit::walk_item(self, i, ());
     }
 
+    fn visit_mac(&mut self, macro: &ast::mac, _: ()) {
+        let ast::mac_invoc_tt(ref path, _, _) = macro.node;
+
+        if path.segments.last().identifier == self.sess.ident_of("macro_rules") {
+            self.gate_feature("macro_rules", path.span, "macro definitions are \
+                not stable enough for use and are subject to change");
+        }
+
+        else if path.segments.last().identifier == self.sess.ident_of("asm") {
+            // NOTE: remove the false once the ASM feature is in the next snapshot
+            if false {
+                self.gate_feature("asm", path.span, "inline assembly is not \
+                    stable enough for use and is subject to change");
+            }
+        }
+    }
+
     fn visit_ty(&mut self, t: &ast::Ty, _: ()) {
         match t.node {
             ast::ty_closure(closure) if closure.onceness == ast::Once => {

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

@@ -563,6 +563,20 @@ impl<'self> PrivacyVisitor<'self> {
                 }
             }
         };
+        let check_struct = |def: &@ast::struct_def| {
+            for f in def.fields.iter() {
+               match f.node.kind {
+                    ast::named_field(_, ast::public) => {
+                        tcx.sess.span_err(f.span, "unnecessary `pub` \
+                                                   visibility");
+                    }
+                    ast::named_field(_, ast::private) => {
+                        // Fields should really be private by default...
+                    }
+                    ast::named_field(*) | ast::unnamed_field => {}
+                }
+            }
+        };
         match item.node {
             // implementations of traits don't need visibility qualifiers because
             // that's controlled by having the trait in scope.
@@ -610,24 +624,16 @@ impl<'self> PrivacyVisitor<'self> {
                         }
                         ast::inherited => {}
                     }
-                }
-            }
 
-            ast::item_struct(ref def, _) => {
-                for f in def.fields.iter() {
-                   match f.node.kind {
-                        ast::named_field(_, ast::public) => {
-                            tcx.sess.span_err(f.span, "unnecessary `pub` \
-                                                       visibility");
-                        }
-                        ast::named_field(_, ast::private) => {
-                            // Fields should really be private by default...
-                        }
-                        ast::named_field(*) | ast::unnamed_field => {}
+                    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 {

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

@@ -2797,13 +2797,23 @@ pub fn declare_intrinsics(llmod: ModuleRef) -> HashMap<&'static str, ValueRef> {
 
     ifn!(intrinsics, "llvm.fabs.f32", [Type::f32()], Type::f32());
     ifn!(intrinsics, "llvm.fabs.f64", [Type::f64()], Type::f64());
+    ifn!(intrinsics, "llvm.copysign.f32", [Type::f32(), Type::f32()], Type::f32());
+    ifn!(intrinsics, "llvm.copysign.f64", [Type::f64(), Type::f64()], Type::f64());
+
     ifn!(intrinsics, "llvm.floor.f32",[Type::f32()], Type::f32());
     ifn!(intrinsics, "llvm.floor.f64",[Type::f64()], Type::f64());
     ifn!(intrinsics, "llvm.ceil.f32", [Type::f32()], Type::f32());
     ifn!(intrinsics, "llvm.ceil.f64", [Type::f64()], Type::f64());
     ifn!(intrinsics, "llvm.trunc.f32",[Type::f32()], Type::f32());
     ifn!(intrinsics, "llvm.trunc.f64",[Type::f64()], Type::f64());
 
+    ifn!(intrinsics, "llvm.rint.f32", [Type::f32()], Type::f32());
+    ifn!(intrinsics, "llvm.rint.f64", [Type::f64()], Type::f64());
+    ifn!(intrinsics, "llvm.nearbyint.f32", [Type::f32()], Type::f32());
+    ifn!(intrinsics, "llvm.nearbyint.f64", [Type::f64()], Type::f64());
+    ifn!(intrinsics, "llvm.round.f32", [Type::f32()], Type::f32());
+    ifn!(intrinsics, "llvm.round.f64", [Type::f64()], Type::f64());
+
     ifn!(intrinsics, "llvm.ctpop.i8", [Type::i8()], Type::i8());
     ifn!(intrinsics, "llvm.ctpop.i16",[Type::i16()], Type::i16());
     ifn!(intrinsics, "llvm.ctpop.i32",[Type::i32()], Type::i32());

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

@@ -460,12 +460,20 @@ pub fn trans_intrinsic(ccx: @mut CrateContext,
         "fmaf64" => simple_llvm_intrinsic(bcx, "llvm.fma.f64", 3),
         "fabsf32" => simple_llvm_intrinsic(bcx, "llvm.fabs.f32", 1),
         "fabsf64" => simple_llvm_intrinsic(bcx, "llvm.fabs.f64", 1),
+        "copysignf32" => simple_llvm_intrinsic(bcx, "llvm.copysign.f32", 2),
+        "copysignf64" => simple_llvm_intrinsic(bcx, "llvm.copysign.f64", 2),
         "floorf32" => simple_llvm_intrinsic(bcx, "llvm.floor.f32", 1),
         "floorf64" => simple_llvm_intrinsic(bcx, "llvm.floor.f64", 1),
         "ceilf32" => simple_llvm_intrinsic(bcx, "llvm.ceil.f32", 1),
         "ceilf64" => simple_llvm_intrinsic(bcx, "llvm.ceil.f64", 1),
         "truncf32" => simple_llvm_intrinsic(bcx, "llvm.trunc.f32", 1),
         "truncf64" => simple_llvm_intrinsic(bcx, "llvm.trunc.f64", 1),
+        "rintf32" => simple_llvm_intrinsic(bcx, "llvm.rint.f32", 1),
+        "rintf64" => simple_llvm_intrinsic(bcx, "llvm.rint.f64", 1),
+        "nearbyintf32" => simple_llvm_intrinsic(bcx, "llvm.nearbyint.f32", 1),
+        "nearbyintf64" => simple_llvm_intrinsic(bcx, "llvm.nearbyint.f64", 1),
+        "roundf32" => simple_llvm_intrinsic(bcx, "llvm.round.f32", 1),
+        "roundf64" => simple_llvm_intrinsic(bcx, "llvm.round.f64", 1),
         "ctpop8" => simple_llvm_intrinsic(bcx, "llvm.ctpop.i8", 1),
         "ctpop16" => simple_llvm_intrinsic(bcx, "llvm.ctpop.i16", 1),
         "ctpop32" => simple_llvm_intrinsic(bcx, "llvm.ctpop.i32", 1),

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

@@ -3807,29 +3807,37 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
                  ~[ ty::mk_f64(), ty::mk_f64(), ty::mk_f64() ],
                  ty::mk_f64())
             }
-            "fabsf32"  => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
-            "fabsf64"  => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
-            "floorf32" => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
-            "floorf64" => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
-            "ceilf32"  => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
-            "ceilf64"  => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
-            "truncf32" => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
-            "truncf64" => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
-            "ctpop8"   => (0, ~[ ty::mk_i8()  ], ty::mk_i8()),
-            "ctpop16"  => (0, ~[ ty::mk_i16() ], ty::mk_i16()),
-            "ctpop32"  => (0, ~[ ty::mk_i32() ], ty::mk_i32()),
-            "ctpop64"  => (0, ~[ ty::mk_i64() ], ty::mk_i64()),
-            "ctlz8"    => (0, ~[ ty::mk_i8()  ], ty::mk_i8()),
-            "ctlz16"   => (0, ~[ ty::mk_i16() ], ty::mk_i16()),
-            "ctlz32"   => (0, ~[ ty::mk_i32() ], ty::mk_i32()),
-            "ctlz64"   => (0, ~[ ty::mk_i64() ], ty::mk_i64()),
-            "cttz8"    => (0, ~[ ty::mk_i8()  ], ty::mk_i8()),
-            "cttz16"   => (0, ~[ ty::mk_i16() ], ty::mk_i16()),
-            "cttz32"   => (0, ~[ ty::mk_i32() ], ty::mk_i32()),
-            "cttz64"   => (0, ~[ ty::mk_i64() ], ty::mk_i64()),
-            "bswap16"  => (0, ~[ ty::mk_i16() ], ty::mk_i16()),
-            "bswap32"  => (0, ~[ ty::mk_i32() ], ty::mk_i32()),
-            "bswap64"  => (0, ~[ ty::mk_i64() ], ty::mk_i64()),
+            "fabsf32"      => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
+            "fabsf64"      => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
+            "copysignf32"  => (0, ~[ ty::mk_f32(), ty::mk_f32() ], ty::mk_f32()),
+            "copysignf64"  => (0, ~[ ty::mk_f64(), ty::mk_f64() ], ty::mk_f64()),
+            "floorf32"     => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
+            "floorf64"     => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
+            "ceilf32"      => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
+            "ceilf64"      => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
+            "truncf32"     => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
+            "truncf64"     => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
+            "rintf32"      => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
+            "rintf64"      => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
+            "nearbyintf32" => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
+            "nearbyintf64" => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
+            "roundf32"     => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
+            "roundf64"     => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
+            "ctpop8"       => (0, ~[ ty::mk_i8()  ], ty::mk_i8()),
+            "ctpop16"      => (0, ~[ ty::mk_i16() ], ty::mk_i16()),
+            "ctpop32"      => (0, ~[ ty::mk_i32() ], ty::mk_i32()),
+            "ctpop64"      => (0, ~[ ty::mk_i64() ], ty::mk_i64()),
+            "ctlz8"        => (0, ~[ ty::mk_i8()  ], ty::mk_i8()),
+            "ctlz16"       => (0, ~[ ty::mk_i16() ], ty::mk_i16()),
+            "ctlz32"       => (0, ~[ ty::mk_i32() ], ty::mk_i32()),
+            "ctlz64"       => (0, ~[ ty::mk_i64() ], ty::mk_i64()),
+            "cttz8"        => (0, ~[ ty::mk_i8()  ], ty::mk_i8()),
+            "cttz16"       => (0, ~[ ty::mk_i16() ], ty::mk_i16()),
+            "cttz32"       => (0, ~[ ty::mk_i32() ], ty::mk_i32()),
+            "cttz64"       => (0, ~[ ty::mk_i64() ], ty::mk_i64()),
+            "bswap16"      => (0, ~[ ty::mk_i16() ], ty::mk_i16()),
+            "bswap32"      => (0, ~[ ty::mk_i32() ], ty::mk_i32()),
+            "bswap64"      => (0, ~[ ty::mk_i64() ], ty::mk_i64()),
 
             "i8_add_with_overflow" | "i8_sub_with_overflow" | "i8_mul_with_overflow" =>
                 (0, ~[ty::mk_i8(), ty::mk_i8()],

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

@@ -47,10 +47,6 @@ condition! {
     pub no_rust_path: (~str) -> Path;
 }
 
-condition! {
-    pub not_a_workspace: (~str) -> Path;
-}
-
 condition! {
     pub failed_to_create_temp_dir: (~str) -> Path;
 }

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

@@ -19,8 +19,8 @@ use crate::Crate;
 use messages::*;
 use source_control::{safe_git_clone, git_clone_url, DirToUse, CheckedOutSources};
 use source_control::make_read_only;
-use path_util::{find_dir_using_rust_path_hack, make_dir_rwx_recursive};
-use path_util::{target_build_dir, versionize};
+use path_util::{find_dir_using_rust_path_hack, make_dir_rwx_recursive, default_workspace};
+use path_util::{target_build_dir, versionize, dir_has_crate_file};
 use util::{compile_crate, DepMap};
 use workcache_support;
 use workcache_support::crate_tag;
@@ -197,7 +197,23 @@ impl PkgSrc {
                 match ok_d {
                     Some(d) => d,
                     None => {
-                        if use_rust_path_hack {
+                        // See if the sources are in $CWD
+                        let cwd = os::getcwd();
+                        if dir_has_crate_file(&cwd) {
+                            return PkgSrc {
+                                // In this case, source_workspace isn't really a workspace.
+                                // This data structure needs yet more refactoring.
+                                source_workspace: cwd.clone(),
+                                destination_workspace: default_workspace(),
+                                build_in_destination: true,
+                                start_dir: cwd,
+                                id: id,
+                                libs: ~[],
+                                mains: ~[],
+                                benchs: ~[],
+                                tests: ~[]
+                            }
+                        } else if use_rust_path_hack {
                             match find_dir_using_rust_path_hack(&id) {
                                 Some(d) => d,
                                 None => {

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

@@ -414,6 +414,11 @@ pub fn uninstall_package_from(workspace: &Path, pkgid: &PkgId) {
 
 }
 
+pub fn dir_has_crate_file(dir: &Path) -> bool {
+    dir_has_file(dir, "lib.rs") || dir_has_file(dir, "main.rs")
+        || dir_has_file(dir, "test.rs") || dir_has_file(dir, "bench.rs")
+}
+
 fn dir_has_file(dir: &Path, file: &str) -> bool {
     assert!(dir.is_absolute());
     os::path_exists(&dir.join(file))
@@ -427,8 +432,7 @@ pub fn find_dir_using_rust_path_hack(p: &PkgId) -> Option<Path> {
         // has a name that's a single component
         if dir.ends_with_path(&p.path) || dir.ends_with_path(&versionize(&p.path, &p.version)) {
             debug2!("In find_dir_using_rust_path_hack: checking dir {}", dir.display());
-            if dir_has_file(dir, "lib.rs") || dir_has_file(dir, "main.rs")
-                || dir_has_file(dir, "test.rs") || dir_has_file(dir, "bench.rs") {
+            if dir_has_crate_file(dir) {
                 debug2!("Did find id {} in dir {}", p.to_str(), dir.display());
                 return Some(dir.clone());
             }