---

yaml
---
r: 10413
b: refs/heads/snap-stage3
c: d14d415
h: refs/heads/master
i:
  10411: 19fdf15
v: v3

Author: bstrie

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: 2898dcc5d97da9427ac367542382b6239d9c0bbf
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 7ec171f6ae795050e571dad2c5122ded584e2505
+refs/heads/snap-stage3: d14d4155dead7a18b2d5b8dcac1dd7311a26900a
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/snap-stage3/doc/tutorial.md

@@ -1382,7 +1382,83 @@ gets access to them.
 
 ## Safe references
 
-*This system has recently changed.  An explanantion is forthcoming.*
+There is one catch with this approach: sometimes the compiler can
+*not* statically guarantee that the argument value at the caller side
+will survive to the end of the call. Another argument might indirectly
+refer to it and be used to overwrite it, or a closure might assign a
+new value to it.
+
+Fortunately, Rust tasks are single-threaded worlds, which share no
+data with other tasks, and most data is immutable. This allows most
+argument-passing situations to be proved safe without further
+difficulty.
+
+Take the following program:
+
+~~~~
+# fn get_really_big_record() -> int { 1 }
+# fn myfunc(a: int) {}
+fn main() {
+    let x = get_really_big_record();
+    myfunc(x);
+}
+~~~~
+
+Here we know for sure that no one else has access to the `x` variable
+in `main`, so we're good. But the call could also look like this:
+
+~~~~
+# fn myfunc(a: int, b: fn()) {}
+# fn get_another_record() -> int { 1 }
+# let mut x = 1;
+myfunc(x, {|| x = get_another_record(); });
+~~~~
+
+Now, if `myfunc` first calls its second argument and then accesses its
+first argument, it will see a different value from the one that was
+passed to it.
+
+In such a case, the compiler will insert an implicit copy of `x`,
+*except* if `x` contains something mutable, in which case a copy would
+result in code that behaves differently. If copying `x` might be
+expensive (for example, if it holds a vector), the compiler will emit
+a warning.
+
+There are even more tricky cases, in which the Rust compiler is forced
+to pessimistically assume a value will get mutated, even though it is
+not sure.
+
+~~~~
+fn for_each(v: [mut @int], iter: fn(@int)) {
+   for v.each {|elt| iter(elt); }
+}
+~~~~
+
+For all this function knows, calling `iter` (which is a closure that
+might have access to the vector that's passed as `v`) could cause the
+elements in the vector to be mutated, with the effect that it can not
+guarantee that the boxes will live for the duration of the call. So it
+has to copy them. In this case, this will happen implicitly (bumping a
+reference count is considered cheap enough to not warn about it).
+
+## The copy operator
+
+If the `for_each` function given above were to take a vector of
+`{mut a: int}` instead of `@int`, it would not be able to
+implicitly copy, since if the `iter` function changes a copy of a
+mutable record, the changes won't be visible in the record itself. If
+we *do* want to allow copies there, we have to explicitly allow it
+with the `copy` operator:
+
+~~~~
+type mutrec = {mut x: int};
+fn for_each(v: [mut mutrec], iter: fn(mutrec)) {
+   for v.each {|elt| iter(copy elt); }
+}
+~~~~
+
+Adding a `copy` operator is also the way to muffle warnings about
+implicit copies.
 
 ## Other uses of safe references
 

branches/snap-stage3/src/libcore/int-template.rs

@@ -1,6 +1,5 @@
 import T = inst::T;
 import cmp::{eq, ord};
-import num::num;
 
 export min_value, max_value;
 export min, max;
@@ -124,7 +123,7 @@ impl eq of eq for T {
     }
 }
 
-impl num of num for T {
+impl num of num::num for T {
     fn add(&&other: T)    -> T { ret self + other; }
     fn sub(&&other: T)    -> T { ret self - other; }
     fn mul(&&other: T)    -> T { ret self * other; }
@@ -196,7 +195,7 @@ fn test_to_str() {
 
 #[test]
 fn test_ifaces() {
-    fn test<U:num>(ten: U) {
+    fn test<U:num::num>(ten: U) {
         assert (ten.to_int() == 10);
 
         let two = ten.from_int(2);

branches/snap-stage3/src/libcore/str.rs

@@ -592,22 +592,7 @@ Section: Comparing strings
 */
 
 #[doc = "Bytewise string equality"]
-pure fn eq(&&a: str, &&b: str) -> bool {
-    // FIXME: This should just be "a == b" but that calls into the shape code
-    // :(
-    let a_len = a.len();
-    let b_len = b.len();
-    if a_len != b_len { ret false; }
-    let mut end = uint::min(a_len, b_len);
-
-    let mut i = 0u;
-    while i < end {
-        if a[i] != b[i] { ret false; }
-        i += 1u;
-    }
-
-    ret true;
-}
+pure fn eq(&&a: str, &&b: str) -> bool { a == b }
 
 #[doc = "Bytewise less than or equal"]
 pure fn le(&&a: str, &&b: str) -> bool { a <= b }
@@ -1876,11 +1861,11 @@ impl extensions for str {
 
     Alphanumeric characters are determined by `char::is_alphanumeric`
     "]
-    #[inline]
+    #[inlune]
     fn is_alphanumeric() -> bool { is_alphanumeric(self) }
     #[inline]
     #[doc ="Returns the size in bytes not counting the null terminator"]
-    pure fn len() -> uint { len(self) }
+    fn len() -> uint { len(self) }
     #[doc = "
     Returns a slice of the given string from the byte range [`begin`..`end`)
 

branches/snap-stage3/src/libcore/uint-template.rs

@@ -1,6 +1,5 @@
 import T = inst::T;
 import cmp::{eq, ord};
-import num::num;
 
 export min_value, max_value;
 export min, max;
@@ -65,7 +64,7 @@ impl eq of eq for T {
     }
 }
 
-impl num of num for T {
+impl num of num::num for T {
     fn add(&&other: T)    -> T { ret self + other; }
     fn sub(&&other: T)    -> T { ret self - other; }
     fn mul(&&other: T)    -> T { ret self * other; }

branches/snap-stage3/src/libsyntax/parse/parser.rs

@@ -70,9 +70,7 @@ class parser {
     let mut token: token::token;
     let mut span: span;
     let mut last_span: span;
-    let mut buffer: [mut {tok: token::token, span: span}]/4;
-    let mut buffer_start: int;
-    let mut buffer_end: int;
+    let buffer: dvec<{tok: token::token, span: span}>;
     let mut restriction: restriction;
     let reader: reader;
     let keywords: hashmap<str, ()>;
@@ -88,14 +86,7 @@ class parser {
         self.token = tok0.tok;
         self.span = span0;
         self.last_span = span0;
-        self.buffer = [mut
-            {tok: tok0.tok, span: span0},
-            {tok: tok0.tok, span: span0},
-            {tok: tok0.tok, span: span0},
-            {tok: tok0.tok, span: span0}
-        ]/4;
-        self.buffer_start = 0;
-        self.buffer_end = 0;
+        self.buffer = dvec::dvec();
         self.restriction = UNRESTRICTED;
         self.reader = rdr;
         self.keywords = token::keyword_table();
@@ -107,13 +98,12 @@ class parser {
 
     fn bump() {
         self.last_span = self.span;
-        if self.buffer_start == self.buffer_end {
+        if self.buffer.len() == 0u {
             let next = lexer::next_token(self.reader);
             self.token = next.tok;
             self.span = mk_sp(next.chpos, self.reader.chpos);
         } else {
-            let next = self.buffer[self.buffer_start];
-            self.buffer_start = (self.buffer_start + 1) & 3;
+            let next = self.buffer.shift();
             self.token = next.tok;
             self.span = next.span;
         }
@@ -122,21 +112,13 @@ class parser {
         self.token = next;
         self.span = mk_sp(lo, hi);
     }
-    fn buffer_length() -> int {
-        if self.buffer_start <= self.buffer_end {
-            ret self.buffer_end - self.buffer_start;
-        }
-        ret (4 - self.buffer_start) + self.buffer_end;
-    }
     fn look_ahead(distance: uint) -> token::token {
-        let dist = distance as int;
-        while self.buffer_length() < dist {
+        while self.buffer.len() < distance {
             let next = lexer::next_token(self.reader);
             let sp = mk_sp(next.chpos, self.reader.chpos);
-            self.buffer[self.buffer_end] = {tok: next.tok, span: sp};
-            self.buffer_end = (self.buffer_end + 1) & 3;
+            self.buffer.push({tok: next.tok, span: sp});
         }
-        ret copy self.buffer[(self.buffer_start + dist - 1) & 3].tok;
+        ret self.buffer[distance - 1u].tok;
     }
     fn fatal(m: str) -> ! {
         self.sess.span_diagnostic.span_fatal(copy self.span, m)

branches/snap-stage3/src/rustc/driver/driver.rs

@@ -204,6 +204,9 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg,
     let (root_map, mutbl_map) = time(
         time_passes, "borrow checking",
         bind middle::borrowck::check_crate(ty_cx, method_map, crate));
+    let (copy_map, _ref_map) =
+        time(time_passes, "alias checking",
+             bind middle::alias::check_crate(ty_cx, crate));
     time(time_passes, "kind checking",
          bind kind::check_crate(ty_cx, method_map, last_use_map, crate));
     time(time_passes, "lint checking",
@@ -213,7 +216,7 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg,
     let outputs = option::get(outputs);
 
     let maps = {mutbl_map: mutbl_map, root_map: root_map,
-                last_use_map: last_use_map,
+                copy_map: copy_map, last_use_map: last_use_map,
                 impl_map: impl_map, method_map: method_map,
                 vtable_map: vtable_map};
 
@@ -445,6 +448,14 @@ fn build_session_options(match: getopts::match,
     let sysroot_opt = getopts::opt_maybe_str(match, "sysroot");
     let target_opt = getopts::opt_maybe_str(match, "target");
     let save_temps = getopts::opt_present(match, "save-temps");
+    let borrowck = alt getopts::opt_maybe_str(match, "borrowck") {
+      none { 0u }
+      some("warn") { 1u }
+      some("err") { 2u }
+      some(_) {
+        early_error(demitter, "borrowck may be warn or err")
+      }
+    };
     alt output_type {
       // unless we're emitting huamn-readable assembly, omit comments.
       link::output_type_llvm_assembly | link::output_type_assembly {}
@@ -493,7 +504,8 @@ fn build_session_options(match: getopts::match,
           test: test,
           parse_only: parse_only,
           no_trans: no_trans,
-          debugging_opts: debugging_opts};
+          debugging_opts: debugging_opts,
+          borrowck: borrowck};
     ret sopts;
 }
 
@@ -570,7 +582,8 @@ fn opts() -> [getopts::opt] {
          optmulti("Z"),
 
          optmulti("cfg"), optflag("test"),
-         optflag("lib"), optflag("bin"), optflag("static"), optflag("gc")];
+         optflag("lib"), optflag("bin"), optflag("static"), optflag("gc"),
+         optopt("borrowck")];
 }
 
 type output_filenames = @{out_filename: str, obj_filename:str};

branches/snap-stage3/src/rustc/driver/session.rs

@@ -66,6 +66,9 @@ type options =
      no_trans: bool,
 
      debugging_opts: uint,
+
+     // temporary hack: 0=off,1=warn,2=err --> if 2, alias is disabled
+     borrowck: uint,
     };
 
 type crate_metadata = {name: str, data: [u8]};
@@ -178,7 +181,8 @@ fn basic_options() -> @options {
         test: false,
         parse_only: false,
         no_trans: false,
-        debugging_opts: 0u
+        debugging_opts: 0u,
+        borrowck: 0u,
     }
 }
 

branches/snap-stage3/src/rustc/metadata/common.rs

@@ -116,6 +116,7 @@ enum astencode_tag { // Reserves 0x50 -- 0x6f
     tag_table_param_bounds,
     tag_table_inferred_modes,
     tag_table_mutbl,
+    tag_table_copy,
     tag_table_last_use,
     tag_table_spill,
     tag_table_method_map,