---

yaml
---
r: 60085
b: refs/heads/master
c: 80061ec
h: refs/heads/master
i:
  60083: de608c1
v: v3

Author: brson

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: eb5fa061136a1f4eb4d7c3c58f396edea43c234d
+refs/heads/master: 80061ecb1d11afd7c450673676e7708f85b73f12
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/try: c50a9d5b664478e533ba1d1d353213d70c8ad589

trunk/mk/host.mk

@@ -130,8 +130,10 @@ $$(HLIB$(2)_H_$(4))/$(CFG_RUSTLLVM_$(4)): \
 $$(HBIN$(2)_H_$(4))/:
 	mkdir -p $$@
 
+ifneq ($(CFG_LIBDIR),bin)
 $$(HLIB$(2)_H_$(4))/:
 	mkdir -p $$@
+endif
 
 endef
 

trunk/mk/install.mk

@@ -192,9 +192,9 @@ ifeq ($(CFG_ADB_DEVICE_STATUS),true)
 ifdef VERBOSE
  ADB = adb $(1)
  ADB_PUSH = adb push $(1) $(2)
- ADB_SHELL = adb shell $(1) $(2) 
+ ADB_SHELL = adb shell $(1) $(2)
 else
- ADB = $(Q)$(call E, adb $(1)) && adb $(1) 1>/dev/null 
+ ADB = $(Q)$(call E, adb $(1)) && adb $(1) 1>/dev/null
  ADB_PUSH = $(Q)$(call E, adb push $(1)) && adb push $(1) $(2) 1>/dev/null
  ADB_SHELL = $(Q)$(call E, adb shell $(1) $(2)) && adb shell $(1) $(2) 1>/dev/null
 endif
@@ -222,8 +222,8 @@ install-runtime-target: \
 	install-runtime-target-arm-linux-androideabi-cleanup \
 	install-runtime-target-arm-linux-androideabi-host-$(CFG_BUILD_TRIPLE)
 else
-install-runtime-target: 
+install-runtime-target:
 	@echo "No device to install runtime library"
-	@echo 
+	@echo
 endif
 endif

trunk/mk/rt.mk

@@ -163,8 +163,6 @@ endif
 ifdef CFG_WINDOWSY_$(1)
 $$(LIBUV_LIB_$(1)): $$(LIBUV_DEPS)
 	$$(Q)$$(MAKE) -C $$(S)src/libuv/ \
-		CFLAGS="$$(CFG_GCCISH_CFLAGS)" \
-		LDFLAGS="$$(CFG_GCCISH_LINK_FLAGS)" \
 		builddir_name="$$(CFG_BUILD_DIR)/rt/$(1)/libuv" \
 		OS=mingw \
 		V=$$(VERBOSE)

trunk/mk/target.mk

@@ -86,8 +86,10 @@ endif
 $$(TBIN$(1)_T_$(2)_H_$(3))/:
 	mkdir -p $$@
 
+ifneq ($(CFG_LIBDIR),bin)
 $$(TLIB$(1)_T_$(2)_H_$(3))/:
 	mkdir -p $$@
+endif
 
 endef
 

trunk/mk/tests.mk

@@ -92,7 +92,7 @@ endef
 $(foreach target,$(CFG_TARGET_TRIPLES), \
   $(eval $(call DEF_TARGET_COMMANDS,$(target))))
 
-# Target platform specific variables 
+# Target platform specific variables
 # for arm-linux-androidabi
 define DEF_ADB_DEVICE_STATUS
 CFG_ADB_DEVICE_STATUS=$(1)
@@ -402,7 +402,7 @@ $(foreach host,$(CFG_HOST_TRIPLES), \
        $(eval $(call DEF_TEST_CRATE_RULES_null,$(stage),$(target),$(host),$(crate))) \
       ), \
       $(eval $(call DEF_TEST_CRATE_RULES,$(stage),$(target),$(host),$(crate))) \
-     )))))) 
+     ))))))
 
 
 ######################################################################

trunk/src/etc/vim/after/ftplugin/rust.vim

@@ -1,5 +1,5 @@
 "Highlight the 100th text column
 "Feature became available in v7.3
 if version >= 703
-    set colorcolumn=100
+    setlocal colorcolumn=100
 endif

trunk/src/etc/vim/after/syntax/rust.vim

@@ -1,4 +1,4 @@
-if exists('g:no_rust_conceal') || !has('conceal') || &enc != 'utf-8'
+if !exists('g:rust_conceal') || !has('conceal') || &enc != 'utf-8'
 	finish
 endif
 

trunk/src/etc/vim/indent/rust.vim

@@ -5,4 +5,7 @@ if exists("b:did_indent")
 endif
 
 let b:did_indent = 1
-setlocal smartindent
+
+setlocal cindent
+setlocal cinoptions=L0,(0,Ws,JN
+setlocal cinkeys=0{,0},!^F,o,O

trunk/src/etc/vim/syntax/rust.vim

@@ -29,7 +29,7 @@ syn match     rustIdentifier  contains=rustIdentifierPrime "\%([^[:cntrl:][:spac
 syn match     rustFuncName    "\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*" display contained
 
 " Reserved words
-syn keyword   rustKeyword     m32 m64 m128 f80 f16 f128 be
+"syn keyword   rustKeyword     m32 m64 m128 f80 f16 f128 be " These are obsolete
 
 syn keyword   rustType        int uint float char bool u8 u16 u32 u64 f32
 syn keyword   rustType        f64 i8 i16 i32 i64 str Self

trunk/src/libcore/hashmap.rs

@@ -352,16 +352,27 @@ impl<K:Hash + Eq,V> Map<K, V> for HashMap<K, V> {
     }
 
     /// Return a mutable reference to the value corresponding to the key
+    #[cfg(stage0)]
     fn find_mut<'a>(&'a mut self, k: &K) -> Option<&'a mut V> {
         let idx = match self.bucket_for_key(k) {
             FoundEntry(idx) => idx,
             TableFull | FoundHole(_) => return None
         };
-        unsafe {  // FIXME(#4903)---requires flow-sensitive borrow checker
+        unsafe {
             Some(::cast::transmute_mut_region(self.mut_value_for_bucket(idx)))
         }
     }
 
+    /// Return a mutable reference to the value corresponding to the key
+    #[cfg(not(stage0))]
+    fn find_mut<'a>(&'a mut self, k: &K) -> Option<&'a mut V> {
+        let idx = match self.bucket_for_key(k) {
+            FoundEntry(idx) => idx,
+            TableFull | FoundHole(_) => return None
+        };
+        Some(self.mut_value_for_bucket(idx))
+    }
+
     /// Insert a key-value pair into the map. An existing value for a
     /// key is replaced by the new value. Return true if the key did
     /// not already exist in the map.
@@ -424,6 +435,7 @@ pub impl<K: Hash + Eq, V> HashMap<K, V> {
 
     /// Return the value corresponding to the key in the map, or insert
     /// and return the value if it doesn't exist.
+    #[cfg(stage0)]
     fn find_or_insert<'a>(&'a mut self, k: K, v: V) -> &'a V {
         if self.size >= self.resize_at {
             // n.b.: We could also do this after searching, so
@@ -447,13 +459,43 @@ pub impl<K: Hash + Eq, V> HashMap<K, V> {
             },
         };
 
-        unsafe { // FIXME(#4903)---requires flow-sensitive borrow checker
+        unsafe {
             ::cast::transmute_region(self.value_for_bucket(idx))
         }
     }
 
+    /// Return the value corresponding to the key in the map, or insert
+    /// and return the value if it doesn't exist.
+    #[cfg(not(stage0))]
+    fn find_or_insert<'a>(&'a mut self, k: K, v: V) -> &'a V {
+        if self.size >= self.resize_at {
+            // n.b.: We could also do this after searching, so
+            // that we do not resize if this call to insert is
+            // simply going to update a key in place.  My sense
+            // though is that it's worse to have to search through
+            // buckets to find the right spot twice than to just
+            // resize in this corner case.
+            self.expand();
+        }
+
+        let hash = k.hash_keyed(self.k0, self.k1) as uint;
+        let idx = match self.bucket_for_key_with_hash(hash, &k) {
+            TableFull => fail!(~"Internal logic error"),
+            FoundEntry(idx) => idx,
+            FoundHole(idx) => {
+                self.buckets[idx] = Some(Bucket{hash: hash, key: k,
+                                     value: v});
+                self.size += 1;
+                idx
+            },
+        };
+
+        self.value_for_bucket(idx)
+    }
+
     /// Return the value corresponding to the key in the map, or create,
     /// insert, and return a new value if it doesn't exist.
+    #[cfg(stage0)]
     fn find_or_insert_with<'a>(&'a mut self, k: K, f: &fn(&K) -> V) -> &'a V {
         if self.size >= self.resize_at {
             // n.b.: We could also do this after searching, so
@@ -478,11 +520,41 @@ pub impl<K: Hash + Eq, V> HashMap<K, V> {
             },
         };
 
-        unsafe { // FIXME(#4903)---requires flow-sensitive borrow checker
+        unsafe {
             ::cast::transmute_region(self.value_for_bucket(idx))
         }
     }
 
+    /// Return the value corresponding to the key in the map, or create,
+    /// insert, and return a new value if it doesn't exist.
+    #[cfg(not(stage0))]
+    fn find_or_insert_with<'a>(&'a mut self, k: K, f: &fn(&K) -> V) -> &'a V {
+        if self.size >= self.resize_at {
+            // n.b.: We could also do this after searching, so
+            // that we do not resize if this call to insert is
+            // simply going to update a key in place.  My sense
+            // though is that it's worse to have to search through
+            // buckets to find the right spot twice than to just
+            // resize in this corner case.
+            self.expand();
+        }
+
+        let hash = k.hash_keyed(self.k0, self.k1) as uint;
+        let idx = match self.bucket_for_key_with_hash(hash, &k) {
+            TableFull => fail!(~"Internal logic error"),
+            FoundEntry(idx) => idx,
+            FoundHole(idx) => {
+                let v = f(&k);
+                self.buckets[idx] = Some(Bucket{hash: hash, key: k,
+                                     value: v});
+                self.size += 1;
+                idx
+            },
+        };
+
+        self.value_for_bucket(idx)
+    }
+
     fn consume(&mut self, f: &fn(K, V)) {
         let mut buckets = ~[];
         self.buckets <-> buckets;

trunk/src/libcore/num/cmath.rs

@@ -33,7 +33,8 @@ pub mod c_double_utils {
         unsafe fn erf(n: c_double) -> c_double;
         unsafe fn erfc(n: c_double) -> c_double;
         unsafe fn exp(n: c_double) -> c_double;
-        unsafe fn expm1(n: c_double) -> c_double;
+        // rename: for consistency with underscore usage elsewhere
+        #[link_name="expm1"] unsafe fn exp_m1(n: c_double) -> c_double;
         unsafe fn exp2(n: c_double) -> c_double;
         #[link_name="fabs"] unsafe fn abs(n: c_double) -> c_double;
         // rename: for clarity and consistency with add/sub/mul/div
@@ -63,7 +64,7 @@ pub mod c_double_utils {
         // renamed: "logb" /often/ is confused for log2 by beginners
         #[link_name="logb"] unsafe fn log_radix(n: c_double) -> c_double;
         // renamed: to be consitent with log as ln
-        #[link_name="log1p"] unsafe fn ln1p(n: c_double) -> c_double;
+        #[link_name="log1p"] unsafe fn ln_1p(n: c_double) -> c_double;
         unsafe fn log10(n: c_double) -> c_double;
         unsafe fn log2(n: c_double) -> c_double;
         #[link_name="ilogb"] unsafe fn ilog_radix(n: c_double) -> c_int;
@@ -117,7 +118,7 @@ pub mod c_float_utils {
         #[link_name="erff"] unsafe fn erf(n: c_float) -> c_float;
         #[link_name="erfcf"] unsafe fn erfc(n: c_float) -> c_float;
         #[link_name="expf"] unsafe fn exp(n: c_float) -> c_float;
-        #[link_name="expm1f"]unsafe fn expm1(n: c_float) -> c_float;
+        #[link_name="expm1f"]unsafe fn exp_m1(n: c_float) -> c_float;
         #[link_name="exp2f"] unsafe fn exp2(n: c_float) -> c_float;
         #[link_name="fabsf"] unsafe fn abs(n: c_float) -> c_float;
         #[link_name="fdimf"]
@@ -148,7 +149,7 @@ pub mod c_float_utils {
 
         #[link_name="logf"] unsafe fn ln(n: c_float) -> c_float;
         #[link_name="logbf"] unsafe fn log_radix(n: c_float) -> c_float;
-        #[link_name="log1pf"] unsafe fn ln1p(n: c_float) -> c_float;
+        #[link_name="log1pf"] unsafe fn ln_1p(n: c_float) -> c_float;
         #[link_name="log2f"] unsafe fn log2(n: c_float) -> c_float;
         #[link_name="log10f"] unsafe fn log10(n: c_float) -> c_float;
         #[link_name="ilogbf"] unsafe fn ilog_radix(n: c_float) -> c_int;