---

yaml
---
r: 85707
b: refs/heads/dist-snap
c: 9e1e152
h: refs/heads/master
i:
  85705: 7b348c1
  85703: 1cfece6
v: v3

Author: bors

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 0983ebe5310d4eb6d289f636f7ed0536c08bbc0e
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 651f38258d72742c5961d646f865316f8ea1823c
+refs/heads/dist-snap: 9e1e15209129dad9d3bba90450a43ffb2505df14
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/doc/rust.md

@@ -851,6 +851,38 @@ In this example, the module `quux` re-exports all of the public names defined in
 
 Also note that the paths contained in `use` items are relative to the crate root.
 So, in the previous example, the `use` refers to `quux::foo::*`, and not simply to `foo::*`.
+This also means that top-level module declarations should be at the crate root if direct usage
+of the declared modules within `use` items is desired.  It is also possible to use `self` and `super`
+at the beginning of a `use` item to refer to the current and direct parent modules respectively.
+All rules regarding accessing declared modules in `use` declarations applies to both module declarations
+and `extern mod` declarations.
+
+An example of what will and will not work for `use` items:
+~~~~
+# #[allow(unused_imports)];
+use foo::extra;          // good: foo is at the root of the crate
+use foo::baz::foobaz;    // good: foo is at the root of the crate
+
+mod foo {
+    extern mod extra;
+
+    use foo::extra::list;  // good: foo is at crate root
+//  use extra::*;          // bad:  extra is not at the crate root
+    use self::baz::foobaz; // good: self refers to module 'foo'
+    use foo::bar::foobar;  // good: foo is at crate root
+
+    pub mod bar {
+        pub fn foobar() { }
+    }
+
+    pub mod baz {
+        use super::bar::foobar; // good: super refers to module 'foo'
+        pub fn foobaz() { }
+    }
+}
+
+fn main() {}
+~~~~
 
 ### Functions
 
@@ -1006,20 +1038,25 @@ code_. They are defined in the same way as any other Rust function,
 except that they have the `extern` modifier.
 
 ~~~
+// Declares an extern fn, the ABI defaults to "C" 
 extern fn new_vec() -> ~[int] { ~[] }
+
+// Declares an extern fn with "stdcall" ABI
+extern "stdcall" fn new_vec_stdcall() -> ~[int] { ~[] }
 ~~~
 
-Extern functions may not be called from Rust code,
-but Rust code may take their value as a raw `u8` pointer.
+Unlike normal functions, extern fns have an `extern "ABI" fn()`.
+This is the same type as the functions declared in an extern
+block.
 
 ~~~
 # extern fn new_vec() -> ~[int] { ~[] }
-let fptr: *u8 = new_vec;
+let fptr: extern "C" fn() -> ~[int] = new_vec;
 ~~~
 
-The primary motivation for extern functions is
-to create callbacks for foreign functions that expect to receive function
-pointers.
+Extern functions may be called from Rust code, but
+caution must be taken with respect to the size of the stack
+segment, just as when calling an extern function normally.
 
 ### Type definitions
 
@@ -1384,14 +1421,13 @@ between the Rust ABI and the foreign ABI.
 A number of [attributes](#attributes) control the behavior of external
 blocks.
 
-By default external blocks assume
-that the library they are calling uses the standard C "cdecl" ABI.
-Other ABIs may be specified using the `abi` attribute as in
+By default external blocks assume that the library they are calling
+uses the standard C "cdecl" ABI.  Other ABIs may be specified using
+an `abi` string, as shown here:
 
 ~~~{.xfail-test}
 // Interface to the Windows API
-#[abi = "stdcall"]
-extern { }
+extern "stdcall" { }
 ~~~
 
 The `link_name` attribute allows the name of the library to be specified.
@@ -1407,6 +1443,12 @@ This is particularly useful for creating external blocks for libc,
 which tends to not follow standard library naming conventions
 and is linked to all Rust programs anyway.
 
+The type of a function
+declared in an extern block
+is `extern "abi" fn(A1, ..., An) -> R`,
+where `A1...An` are the declared types of its arguments
+and `R` is the decalred return type.
+
 ## Attributes
 
 ~~~~~~~~{.ebnf .gram}

branches/dist-snap/mk/tests.mk

@@ -144,8 +144,9 @@ CFG_ADB_TEST_DIR=/data/tmp
 
 $(info check: android device test dir $(CFG_ADB_TEST_DIR) ready \
  $(shell adb remount 1>/dev/null) \
- $(shell adb shell mkdir $(CFG_ADB_TEST_DIR) 1>/dev/null) \
- $(shell adb shell rm -rf $(CFG_ADB_TEST_DIR)/* 1>/dev/null) \
+ $(shell adb shell rm -r $(CFG_ADB_TEST_DIR) >/dev/null) \
+ $(shell adb shell mkdir $(CFG_ADB_TEST_DIR)) \
+ $(shell adb shell mkdir $(CFG_ADB_TEST_DIR)/tmp) \
  $(shell adb push $(S)src/etc/adb_run_wrapper.sh $(CFG_ADB_TEST_DIR) 1>/dev/null) \
  $(shell adb push $(CFG_ANDROID_CROSS_PATH)/arm-linux-androideabi/lib/armv7-a/libgnustl_shared.so \
                   $(CFG_ADB_TEST_DIR) 1>/dev/null) \
@@ -239,6 +240,8 @@ tidy:
 		@$(call E, check: formatting)
 		$(Q)find $(S)src -name '*.r[sc]' \
 		| grep '^$(S)src/test' -v \
+		| grep '^$(S)src/libuv' -v \
+		| grep '^$(S)src/llvm' -v \
 		| xargs -n 10 $(CFG_PYTHON) $(S)src/etc/tidy.py
 		$(Q)find $(S)src/etc -name '*.py' \
 		| xargs -n 10 $(CFG_PYTHON) $(S)src/etc/tidy.py
@@ -409,14 +412,16 @@ $$(call TEST_OK_FILE,$(1),$(2),$(3),$(4)): \
 		$(3)/stage$(1)/test/$(4)test-$(2)$$(X_$(2))
 	@$$(call E, run: $$< via adb)
 	@$(CFG_ADB) push $$< $(CFG_ADB_TEST_DIR)
-	@$(CFG_ADB) shell LD_LIBRARY_PATH=$(CFG_ADB_TEST_DIR) \
-        $(CFG_ADB_TEST_DIR)/`echo $$< | sed 's/.*\///'` \
-		--logfile $(CFG_ADB_TEST_DIR)/check-stage$(1)-T-$(2)-H-$(3)-$(4).log > \
-		tmp/check-stage$(1)-T-$(2)-H-$(3)-$(4).tmp
+	@$(CFG_ADB) shell '(cd $(CFG_ADB_TEST_DIR); LD_LIBRARY_PATH=. \
+		./$$(notdir $$<) \
+		--logfile $(CFG_ADB_TEST_DIR)/check-stage$(1)-T-$(2)-H-$(3)-$(4).log \
+		$$(call CRATE_TEST_BENCH_ARGS,$(1),$(2),$(3),$(4)))' \
+		> tmp/check-stage$(1)-T-$(2)-H-$(3)-$(4).tmp
 	@cat tmp/check-stage$(1)-T-$(2)-H-$(3)-$(4).tmp
 	@touch tmp/check-stage$(1)-T-$(2)-H-$(3)-$(4).log
 	@$(CFG_ADB) pull $(CFG_ADB_TEST_DIR)/check-stage$(1)-T-$(2)-H-$(3)-$(4).log tmp/
 	@$(CFG_ADB) shell rm $(CFG_ADB_TEST_DIR)/check-stage$(1)-T-$(2)-H-$(3)-$(4).log
+	@$(CFG_ADB) pull $(CFG_ADB_TEST_DIR)/$$(call TEST_RATCHET_FILE,$(1),$(2),$(3),$(4)) tmp/
 	@if grep -q "result: ok" tmp/check-stage$(1)-T-$(2)-H-$(3)-$(4).tmp; \
 	then \
 		rm tmp/check-stage$(1)-T-$(2)-H-$(3)-$(4).tmp; \

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

@@ -16,27 +16,31 @@ use std::libc::{c_char, c_int};
 use std::local_data;
 use std::str;
 
+#[cfg(stage0)]
 pub mod rustrt {
     use std::libc::{c_char, c_int};
 
-    #[cfg(stage0)]
-    mod macro_hack {
-    #[macro_escape];
-    macro_rules! externfn(
-        (fn $name:ident ($($arg_name:ident : $arg_ty:ty),*) $(-> $ret_ty:ty),*) => (
-            extern {
-                fn $name($($arg_name : $arg_ty),*) $(-> $ret_ty),*;
-            }
-        )
-    )
+    extern {
+        fn linenoise(prompt: *c_char) -> *c_char;
+        fn linenoiseHistoryAdd(line: *c_char) -> c_int;
+        fn linenoiseHistorySetMaxLen(len: c_int) -> c_int;
+        fn linenoiseHistorySave(file: *c_char) -> c_int;
+        fn linenoiseHistoryLoad(file: *c_char) -> c_int;
+        fn linenoiseSetCompletionCallback(callback: *u8);
+        fn linenoiseAddCompletion(completions: *(), line: *c_char);
     }
+}
+
+#[cfg(not(stage0))]
+pub mod rustrt {
+    use std::libc::{c_char, c_int};
 
     externfn!(fn linenoise(prompt: *c_char) -> *c_char)
     externfn!(fn linenoiseHistoryAdd(line: *c_char) -> c_int)
     externfn!(fn linenoiseHistorySetMaxLen(len: c_int) -> c_int)
     externfn!(fn linenoiseHistorySave(file: *c_char) -> c_int)
     externfn!(fn linenoiseHistoryLoad(file: *c_char) -> c_int)
-    externfn!(fn linenoiseSetCompletionCallback(callback: *u8))
+    externfn!(fn linenoiseSetCompletionCallback(callback: extern "C" fn(*i8, *())))
     externfn!(fn linenoiseAddCompletion(completions: *(), line: *c_char))
 }
 

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

@@ -61,6 +61,7 @@ impl Url {
 }
 
 impl UserInfo {
+    #[inline]
     pub fn new(user: ~str, pass: Option<~str>) -> UserInfo {
         UserInfo { user: user, pass: pass }
     }
@@ -460,11 +461,14 @@ fn get_authority(rawurl: &str) ->
               }
               InHost => {
                 pos = i;
-                // can't be sure whether this is an ipv6 address or a port
                 if input == Unreserved {
-                    return Err(~"Illegal characters in authority.");
+                    // must be port
+                    host = rawurl.slice(begin, i).to_owned();
+                    st = InPort;
+                } else {
+                    // can't be sure whether this is an ipv6 address or a port
+                    st = Ip6Port;
                 }
-                st = Ip6Port;
               }
               Ip6Port => {
                 if input == Unreserved {
@@ -514,25 +518,12 @@ fn get_authority(rawurl: &str) ->
           }
           _ => ()
         }
-        end = i;
     }
 
-    let end = end; // make end immutable so it can be captured
-
-    let host_is_end_plus_one: &fn() -> bool = || {
-        let xs = ['?', '#', '/'];
-        end+1 == len
-            && !xs.iter().any(|x| *x == (rawurl[end] as char))
-    };
-
     // finish up
     match st {
       Start => {
-        if host_is_end_plus_one() {
-            host = rawurl.slice(begin, end+1).to_owned();
-        } else {
-            host = rawurl.slice(begin, end).to_owned();
-        }
+        host = rawurl.slice(begin, end).to_owned();
       }
       PassHostPort | Ip6Port => {
         if input != Digit {
@@ -552,8 +543,7 @@ fn get_authority(rawurl: &str) ->
       }
     }
 
-    let rest = if host_is_end_plus_one() { ~"" }
-    else { rawurl.slice(end, len).to_owned() };
+    let rest = rawurl.slice(end, len).to_owned();
     return Ok((userinfo, host, port, rest));
 }
 
@@ -806,18 +796,17 @@ mod tests {
 
     #[test]
     fn test_url_parse() {
-        let url = ~"http://user:[email protected]/doc?s=v#something";
+        let url = ~"http://user:[email protected]:8080/doc?s=v#something";
 
         let up = from_str(url);
         let u = up.unwrap();
-        assert!(u.scheme == ~"http");
-        let userinfo = u.user.get_ref();
-        assert!(userinfo.user == ~"user");
-        assert!(userinfo.pass.get_ref() == &~"pass");
-        assert!(u.host == ~"rust-lang.org");
-        assert!(u.path == ~"/doc");
-        assert!(u.query == ~[(~"s", ~"v")]);
-        assert!(u.fragment.get_ref() == &~"something");
+        assert_eq!(&u.scheme, &~"http");
+        assert_eq!(&u.user, &Some(UserInfo::new(~"user", Some(~"pass"))));
+        assert_eq!(&u.host, &~"rust-lang.org");
+        assert_eq!(&u.port, &Some(~"8080"));
+        assert_eq!(&u.path, &~"/doc");
+        assert_eq!(&u.query, &~[(~"s", ~"v")]);
+        assert_eq!(&u.fragment, &Some(~"something"));
     }
 
     #[test]
@@ -828,6 +817,22 @@ mod tests {
         assert!(url.path == ~"/");
     }
 
+    #[test]
+    fn test_url_host_with_port() {
+        let urlstr = ~"scheme://host:1234";
+        let url = from_str(urlstr).unwrap();
+        assert_eq!(&url.scheme, &~"scheme");
+        assert_eq!(&url.host, &~"host");
+        assert_eq!(&url.port, &Some(~"1234"));
+        assert_eq!(&url.path, &~""); // is empty path really correct? Other tests think so
+        let urlstr = ~"scheme://host:1234/";
+        let url = from_str(urlstr).unwrap();
+        assert_eq!(&url.scheme, &~"scheme");
+        assert_eq!(&url.host, &~"host");
+        assert_eq!(&url.port, &Some(~"1234"));
+        assert_eq!(&url.path, &~"/");
+    }
+
     #[test]
     fn test_url_with_underscores() {
         let urlstr = ~"http://dotcom.com/file_name.html";

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

@@ -1617,7 +1617,7 @@ impl Liveness {
 
     pub fn should_warn(&self, var: Variable) -> Option<@str> {
         let name = self.ir.variable_name(var);
-        if name[0] == ('_' as u8) { None } else { Some(name) }
+        if name.len() == 0 || name[0] == ('_' as u8) { None } else { Some(name) }
     }
 
     pub fn warn_about_unused_args(&self, decl: &fn_decl, entry_ln: LiveNode) {

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

@@ -52,6 +52,7 @@ use middle::trans::expr;
 use middle::trans::foreign;
 use middle::trans::glue;
 use middle::trans::inline;
+use middle::trans::llrepr::LlvmRepr;
 use middle::trans::machine;
 use middle::trans::machine::{llalign_of_min, llsize_of};
 use middle::trans::meth;
@@ -1739,6 +1740,10 @@ pub fn copy_args_to_allocas(fcx: @mut FunctionContext,
                             args: &[ast::arg],
                             raw_llargs: &[ValueRef],
                             arg_tys: &[ty::t]) -> @mut Block {
+    debug!("copy_args_to_allocas: raw_llargs=%s arg_tys=%s",
+           raw_llargs.llrepr(fcx.ccx),
+           arg_tys.repr(fcx.ccx.tcx));
+
     let _icx = push_ctxt("copy_args_to_allocas");
     let mut bcx = bcx;
 

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

@@ -22,6 +22,7 @@ use std::hashmap::HashMap;
 use std::libc::{c_uint, c_ulonglong, c_char};
 use std::vec;
 use syntax::codemap::span;
+use std::ptr::is_not_null;
 
 pub struct Builder {
     llbuilder: BuilderRef,
@@ -483,6 +484,7 @@ impl Builder {
         debug!("Store %s -> %s",
                self.ccx.tn.val_to_str(val),
                self.ccx.tn.val_to_str(ptr));
+        assert!(is_not_null(self.llbuilder));
         self.count_insn("store");
         unsafe {
             llvm::LLVMBuildStore(self.llbuilder, val, ptr);