---

yaml
---
r: 12897
b: refs/heads/master
c: 28d0ce9
h: refs/heads/master
i:
  12895: 17a89de
v: v3

Author: nikomatsakis

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 24cfe29a8a4f4fe4dba16191508e44f98d92ed7f
+refs/heads/master: 28d0ce9a8ba08748877163768f4b846dabc1d4a7
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf

trunk/Makefile.in

@@ -198,7 +198,7 @@ STDLIB_INPUTS := $(wildcard $(addprefix $(S)src/libstd/,          \
 COMPILER_CRATE := $(S)src/rustc/rustc.rc
 COMPILER_INPUTS := $(filter-out $(S)src/rustc/driver/rustc.rs,     \
                        $(wildcard $(addprefix $(S)src/rustc/,      \
-                           rustc.rc *.rs */*.rs */*/*.rs)))
+                           rustc.rc *.rs */*.rs */*/*.rs */*/*/*.rs)))
 
 LIBRUSTSYNTAX_CRATE := $(S)src/librustsyntax/rustsyntax.rc
 LIBRUSTSYNTAX_INPUTS := $(wildcard $(addprefix $(S)src/librustsyntax/, \

trunk/src/cargo/cargo.rs

@@ -18,7 +18,13 @@ import vec;
 import std::getopts;
 import getopts::{optflag, optopt, opt_present};
 
+enum _src {
+    /* Break cycles in package <-> source */
+    _source(source),
+}
+
 type package = {
+//    source: _src,
     name: str,
     uuid: str,
     url: str,
@@ -287,6 +293,7 @@ fn load_one_source_package(&src: source, p: map::hashmap<str, json::json>) {
     };
 
     vec::grow(src.packages, 1u, {
+        // source: _source(src),
         name: name,
         uuid: uuid,
         url: url,

trunk/src/libcore/io.rs

@@ -161,24 +161,6 @@ impl reader_util for reader {
         while !self.eof() { buf += self.read_bytes(2048u); }
         buf
     }
-
-    fn each_byte(it: fn(int) -> bool) {
-        while !self.eof() {
-            if !it(self.read_byte()) { break; }
-        }
-    }
-
-    fn each_char(it: fn(char) -> bool) {
-        while !self.eof() {
-            if !it(self.read_char()) { break; }
-        }
-    }
-
-    fn each_line(it: fn(str) -> bool) {
-        while !self.eof() {
-            if !it(self.read_line()) { break; }
-        }
-    }
 }
 
 // Reader implementations

trunk/src/libstd/sha1.rs

@@ -1,7 +1,7 @@
 #[doc ="
 An implementation of the SHA-1 cryptographic hash.
 
-First create a `sha1` object using the `sha1` constructor, then
+First create a `sha1` object using the `mk_sha1` constructor, then
 feed it input using the `input` or `input_str` methods, which may be
 called any number of times.
 

trunk/src/libstd/time.rs

@@ -7,7 +7,6 @@ export
     get_time,
     precise_time_ns,
     precise_time_s,
-    tzset,
     tm,
     empty_tm,
     now,
@@ -21,7 +20,6 @@ native mod rustrt {
     fn get_time(&sec: i64, &nsec: i32);
     fn precise_time_ns(&ns: u64);
 
-    fn rust_tzset();
     // FIXME: The i64 values can be passed by-val when #2064 is fixed.
     fn rust_gmtime(&&sec: i64, &&nsec: i32, &&result: tm);
     fn rust_localtime(&&sec: i64, &&nsec: i32, &&result: tm);
@@ -61,10 +59,6 @@ fn precise_time_s() -> float {
     ret (precise_time_ns() as float) / 1000000000.;
 }
 
-fn tzset() {
-    rustrt::rust_tzset();
-}
-
 type tm = {
     tm_sec: i32, // seconds after the minute [0-60]
     tm_min: i32, // minutes after the hour [0-59]
@@ -875,7 +869,6 @@ mod tests {
     #[test]
     fn test_at_utc() {
         os::setenv("TZ", "America/Los_Angeles");
-        tzset();
 
         let time = { sec: 1234567890_i64, nsec: 54321_i32 };
         let utc = at_utc(time);
@@ -897,13 +890,10 @@ mod tests {
     #[test]
     fn test_at() {
         os::setenv("TZ", "America/Los_Angeles");
-        tzset();
 
         let time = { sec: 1234567890_i64, nsec: 54321_i32 };
         let local = at(time);
 
-        #error("time_at: %?", local);
-
         assert local.tm_sec == 30_i32;
         assert local.tm_min == 31_i32;
         assert local.tm_hour == 15_i32;
@@ -926,7 +916,6 @@ mod tests {
     #[test]
     fn test_to_timespec() {
         os::setenv("TZ", "America/Los_Angeles");
-        tzset();
 
         let time = { sec: 1234567890_i64, nsec: 54321_i32 };
         let utc = at_utc(time);
@@ -938,7 +927,6 @@ mod tests {
     #[test]
     fn test_conversions() {
         os::setenv("TZ", "America/Los_Angeles");
-        tzset();
 
         let time = { sec: 1234567890_i64, nsec: 54321_i32 };
         let utc = at_utc(time);
@@ -955,7 +943,6 @@ mod tests {
     #[test]
     fn test_strptime() {
         os::setenv("TZ", "America/Los_Angeles");
-        tzset();
 
         alt strptime("", "") {
           ok(tm) {
@@ -1101,22 +1088,18 @@ mod tests {
     #[test]
     fn test_ctime() {
         os::setenv("TZ", "America/Los_Angeles");
-        tzset();
 
         let time = { sec: 1234567890_i64, nsec: 54321_i32 };
         let utc   = at_utc(time);
         let local = at(time);
 
-        #error("test_ctime: %? %?", utc.ctime(), local.ctime());
-
         assert utc.ctime()   == "Fri Feb 13 23:31:30 2009";
         assert local.ctime() == "Fri Feb 13 15:31:30 2009";
     }
 
     #[test]
     fn test_strftime() {
         os::setenv("TZ", "America/Los_Angeles");
-        tzset();
 
         let time = { sec: 1234567890_i64, nsec: 54321_i32 };
         let utc = at_utc(time);

trunk/src/rt/rust_builtin.cpp

@@ -529,11 +529,6 @@ struct tm* LOCALTIME(const time_t *clock, tm *result) {
 #define TIMEGM(result) timegm(result)
 #endif
 
-extern "C" CDECL void
-rust_tzset() {
-    TZSET();
-}
-
 extern "C" CDECL void
 rust_gmtime(int64_t *sec, int32_t *nsec, rust_tm *timeptr) {
     tm tm;
@@ -546,6 +541,7 @@ rust_gmtime(int64_t *sec, int32_t *nsec, rust_tm *timeptr) {
 extern "C" CDECL void
 rust_localtime(int64_t *sec, int32_t *nsec, rust_tm *timeptr) {
     tm tm;
+    TZSET();
     time_t s = *sec;
     LOCALTIME(&s, &tm);
 

trunk/src/rt/rustrt.def.in

@@ -12,7 +12,6 @@ debug_abi_2
 get_port_id
 get_task_id
 get_time
-rust_tzset
 rust_gmtime
 rust_localtime
 rust_timegm

trunk/src/rustc/middle/typeck/check/regionmanip.rs

@@ -1,4 +1,5 @@
 import middle::typeck::infer::{ty_and_region_var_methods};
+import syntax::print::pprust::{expr_to_str};
 
 // Helper functions related to manipulating region types.
 
@@ -113,6 +114,20 @@ fn replace_bound_regions(
  * stack position and so the resulting region will be the enclosing block.
  */
 fn region_of(fcx: @fn_ctxt, expr: @ast::expr) -> ty::region {
+    #debug["region_of(expr=%s)", expr_to_str(expr)];
+    ret alt expr.node {
+      ast::expr_path(path) {
+        def(fcx, expr, lookup_def(fcx, path.span, expr.id))}
+      ast::expr_field(base, _, _) {
+        deref(fcx, base)}
+      ast::expr_index(base, _) {
+        deref(fcx, base)}
+      ast::expr_unary(ast::deref, base) {
+        deref(fcx, base)}
+      _ {
+        borrow(fcx, expr)}
+    };
+
     fn borrow(fcx: @fn_ctxt, expr: @ast::expr) -> ty::region {
         ty::encl_region(fcx.ccx.tcx, expr.id)
     }
@@ -127,24 +142,38 @@ fn region_of(fcx: @fn_ctxt, expr: @ast::expr) -> ty::region {
         }
     }
 
-    alt expr.node {
-      ast::expr_path(path) {
-        let defn = lookup_def(fcx, path.span, expr.id);
-        alt defn {
+    fn def(fcx: @fn_ctxt, expr: @ast::expr, d: ast::def) -> ty::region {
+        alt d {
+          ast::def_arg(local_id, _) |
           ast::def_local(local_id, _) |
-          ast::def_upvar(local_id, _, _) {
+          ast::def_binding(local_id) {
+            #debug["region_of.def/arg/local/binding(id=%d)", local_id];
             let local_scope = fcx.ccx.tcx.region_map.get(local_id);
             ty::re_scope(local_scope)
           }
-          _ {
+          ast::def_upvar(_, inner, _) {
+            #debug["region_of.def/upvar"];
+            def(fcx, expr, *inner)
+          }
+          ast::def_self(*) {
+            alt fcx.in_scope_regions.find(ty::br_self) {
+              some(r) {r}
+              none {
+                // eventually, this should never happen... self should
+                // always be an &self.T rptr
+                borrow(fcx, expr)
+              }
+            }
+          }
+          ast::def_fn(_, _) | ast::def_mod(_) |
+          ast::def_native_mod(_) | ast::def_const(_) |
+          ast::def_use(_) | ast::def_variant(_, _) |
+          ast::def_ty(_) | ast::def_prim_ty(_) |
+          ast::def_ty_param(_, _) | ast::def_class(_) |
+          ast::def_region(_) {
             ty::re_static
           }
         }
-      }
-      ast::expr_field(base, _, _) { deref(fcx, base) }
-      ast::expr_index(base, _) { deref(fcx, base) }
-      ast::expr_unary(ast::deref, base) { deref(fcx, base) }
-      _ { borrow(fcx, expr) }
     }
 }
 

trunk/src/test/compile-fail/regions-addr-of-arg.rs

@@ -0,0 +1,10 @@
+fn foo(a: int) {
+    let _p: &static.int = &a; //! ERROR mismatched types
+}
+
+fn bar(a: int) {
+    let _q: &blk.int = &a;
+}
+
+fn main() {
+}

trunk/src/test/compile-fail/regions-addr-of-self.rs

@@ -0,0 +1,23 @@
+class dog {
+    let mut cats_chased: uint;
+
+    new() {
+        self.cats_chased = 0u;
+    }
+
+    fn chase_cat() {
+        let p: &static.mut uint = &mut self.cats_chased; //! ERROR mismatched types
+        *p += 1u;
+    }
+
+    fn chase_cat_2() {
+        let p: &blk.mut uint = &mut self.cats_chased;
+        *p += 1u;
+    }
+}
+
+fn main() {
+    let d = dog();
+    d.chase_cat();
+    #debug["cats_chased: %u", d.cats_chased];
+}

trunk/src/test/compile-fail/regions-addr-of-upvar-self.rs

@@ -0,0 +1,17 @@
+class dog {
+    let mut food: uint;
+
+    new() {
+        self.food = 0u;
+    }
+
+    fn chase_cat() {
+        uint::range(0u, 10u) { |i|
+            let p: &static.mut uint = &mut self.food; //! ERROR mismatched types
+            *p = 3u;
+        }
+    }
+}
+
+fn main() {
+}