rustc: Implement and enforce instance coherence

Author: pcwalton

src/cargo/cargo.rs

@@ -11,7 +11,7 @@ import result::{ok, err};
 import io::writer_util;
 import std::{map, json, tempfile, term, sort, getopts};
 import map::hashmap;
-import json::to_str;
+import to_str::to_str;
 import getopts::{optflag, optopt, opt_present};
 
 type package = {
@@ -535,7 +535,7 @@ fn load_one_source_package(src: source, p: map::hashmap<~str, json::json>) {
         versions: ~[]
     };
 
-    alt src.packages.position(|pkg| pkg.uuid == uuid ) {
+    alt vec::position(src.packages, |pkg| pkg.uuid == uuid) {
       some(idx) {
         src.packages[idx] = newpkg;
         log(debug, ~"  updated package: " + src.name + ~"/" + name);

src/libcore/core.rs

@@ -5,12 +5,15 @@
 import option::{some, none};
 import option = option::option;
 import path = path::path;
-import str::extensions;
 import tuple::extensions;
+import str::{extensions, str_slice, unique_str};
 import vec::extensions;
+import vec::{const_vector, copyable_vector, immutable_vector};
+import vec::{immutable_copyable_vector, iter_trait_extensions, vec_concat};
+import iter::{base_iter, extended_iter, copyable_iter, times};
 import option::extensions;
 import option_iter::extensions;
-import ptr::extensions;
+import ptr::{extensions, ptr};
 import rand::extensions;
 import result::extensions;
 import int::{num, times};
@@ -26,11 +29,18 @@ import u64::{num, times};
 import float::num;
 import f32::num;
 import f64::num;
+import num::num;
 
 export path, option, some, none, unreachable;
 export extensions;
 // The following exports are the extension impls for numeric types
 export num, times;
+// The following exports are the common traits
+export str_slice, unique_str;
+export const_vector, copyable_vector, immutable_vector;
+export immutable_copyable_vector, iter_trait_extensions, vec_concat;
+export base_iter, copyable_iter, extended_iter;
+export ptr;
 
 // Export the log levels as global constants. Higher levels mean
 // more-verbosity. Error is the bottom level, default logging level is

src/libcore/int-template.rs

@@ -233,6 +233,7 @@ fn test_ifaces() {
 
 #[test]
 fn test_times() {
+    import iter::times;
     let ten = 10 as T;
     let mut accum = 0;
     for ten.times { accum += 1; }
@@ -243,5 +244,6 @@ fn test_times() {
 #[should_fail]
 #[ignore(cfg(windows))]
 fn test_times_negative() {
+    import iter::times;
     for (-10).times { log(error, ~"nope!"); }
 }

src/libcore/iter-trait.rs

@@ -8,6 +8,9 @@ export extensions;
 impl extensions<A> of iter::base_iter<A> for IMPL_T<A> {
     fn each(blk: fn(A) -> bool) { EACH(self, blk) }
     fn size_hint() -> option<uint> { SIZE_HINT(self) }
+}
+
+impl extensions<A> of iter::extended_iter<A> for IMPL_T<A> {
     fn eachi(blk: fn(uint, A) -> bool) { iter::eachi(self, blk) }
     fn all(blk: fn(A) -> bool) -> bool { iter::all(self, blk) }
     fn any(blk: fn(A) -> bool) -> bool { iter::any(self, blk) }

src/libcore/iter.rs

@@ -3,6 +3,16 @@ iface base_iter<A> {
     fn size_hint() -> option<uint>;
 }
 
+trait extended_iter<A> {
+    fn eachi(blk: fn(uint, A) -> bool);
+    fn all(blk: fn(A) -> bool) -> bool;
+    fn any(blk: fn(A) -> bool) -> bool;
+    fn foldl<B>(+b0: B, blk: fn(B, A) -> B) -> B;
+    fn contains(x: A) -> bool;
+    fn count(x: A) -> uint;
+    fn position(f: fn(A) -> bool) -> option<uint>;
+}
+
 iface times {
     fn times(it: fn() -> bool);
 }

src/libcore/option.rs

@@ -92,6 +92,7 @@ pure fn iter<T>(opt: option<T>, f: fn(T)) {
     alt opt { none { } some(t) { f(t); } }
 }
 
+#[inline(always)]
 pure fn unwrap<T>(-opt: option<T>) -> T {
     /*!
      * Moves a value out of an option type and returns it.

src/libcore/pipes.rs

@@ -578,7 +578,11 @@ impl<T: send> of selectable for pipes::port<T> {
 
 type shared_chan<T: send> = arc::exclusive<pipes::chan<T>>;
 
-impl chan<T: send> for shared_chan<T> {
+trait send_on_shared_chan<T> {
+    fn send(+x: T);
+}
+
+impl chan<T: send> of send_on_shared_chan<T> for shared_chan<T> {
     fn send(+x: T) {
         let mut xx = some(x);
         do self.with |_c, chan| {

src/libcore/ptr.rs

@@ -14,6 +14,7 @@ export memset;
 export buf_len;
 export position;
 export extensions;
+export ptr;
 
 import libc::{c_void, size_t};
 

src/libcore/str.rs

@@ -106,7 +106,9 @@ export
    escape_unicode,
 
    unsafe,
-   extensions;
+   extensions,
+   str_slice,
+   unique_str;
 
 #[abi = "cdecl"]
 extern mod rustrt {

src/libcore/uint-template.rs

@@ -278,6 +278,7 @@ fn to_str_radix17() {
 
 #[test]
 fn test_times() {
+    import iter::times;
     let ten = 10 as T;
     let mut accum = 0;
     for ten.times { accum += 1; }

src/libcore/vec.rs

@@ -85,6 +85,12 @@ export unpack_const_slice;
 export unsafe;
 export u8;
 export extensions;
+export const_vector;
+export copyable_vector;
+export immutable_vector;
+export immutable_copyable_vector;
+export iter_trait_extensions;
+export vec_concat;
 
 #[abi = "cdecl"]
 extern mod rustrt {
@@ -179,11 +185,12 @@ pure fn len<T>(&&v: &[const T]) -> uint {
  * Creates an immutable vector of size `n_elts` and initializes the elements
  * to the value returned by the function `op`.
  */
-pure fn from_fn<T>(n_elts: uint, op: init_op<T>) -> ~[T] {
+pure fn from_fn<T: copy>(n_elts: uint, op: init_op<T>) -> ~[T] {
     let mut v = ~[];
     unchecked{reserve(v, n_elts);}
     let mut i: uint = 0u;
-    while i < n_elts unsafe { push(v, op(i)); i += 1u; }
+    while i < n_elts unsafe { ref_set(v, i, op(i)); i += 1u; }
+    unsafe { unsafe::set_len(v, n_elts); }
     ret v;
 }
 
@@ -197,8 +204,9 @@ pure fn from_elem<T: copy>(n_elts: uint, t: T) -> ~[T] {
     let mut v = ~[];
     unchecked{reserve(v, n_elts)}
     let mut i: uint = 0u;
-    unsafe { // because push is impure
-        while i < n_elts { push(v, t); i += 1u; }
+    unsafe { // because ref_set is unsafe
+        while i < n_elts { ref_set(v, i, t); i += 1u; }
+        unsafe { unsafe::set_len(v, n_elts); }
     }
     ret v;
 }
@@ -468,6 +476,16 @@ unsafe fn ref<T: copy>(v: &[const T], i: uint) -> T {
     unpack_slice(v, |p, _len| *ptr::offset(p, i))
 }
 
+#[inline(always)]
+unsafe fn ref_set<T: copy>(v: &[mut T], i: uint, +val: T) {
+    let mut box = some(val);
+    do unpack_mut_slice(v) |p, _len| {
+        let mut box2 = none;
+        box2 <-> box;
+        rusti::move_val_init(*ptr::mut_offset(p, i), option::unwrap(box2));
+    }
+}
+
 #[inline(always)]
 fn push_all<T: copy>(&v: ~[const T], rhs: &[const T]) {
     reserve(v, v.len() + rhs.len());
@@ -1591,6 +1609,9 @@ mod u8 {
 impl extensions/&<A> of iter::base_iter<A> for &[const A] {
     fn each(blk: fn(A) -> bool) { each(self, blk) }
     fn size_hint() -> option<uint> { some(len(self)) }
+}
+
+impl extensions/&<A> of iter::extended_iter<A> for &[const A] {
     fn eachi(blk: fn(uint, A) -> bool) { iter::eachi(self, blk) }
     fn all(blk: fn(A) -> bool) -> bool { iter::all(self, blk) }
     fn any(blk: fn(A) -> bool) -> bool { iter::any(self, blk) }
@@ -1599,6 +1620,7 @@ impl extensions/&<A> of iter::base_iter<A> for &[const A] {
     }
     fn contains(x: A) -> bool { iter::contains(self, x) }
     fn count(x: A) -> uint { iter::count(self, x) }
+    fn position(f: fn(A) -> bool) -> option<uint> { iter::position(self, f) }
 }
 
 trait iter_trait_extensions<A> {

src/libstd/arena.rs

@@ -6,7 +6,12 @@ import list;
 import list::{list, cons, nil};
 
 type chunk = {data: ~[u8], mut fill: uint};
-type arena = {mut chunks: @list<@chunk>};
+
+type arena_ = {mut chunks: @list<@chunk>};
+
+enum arena {
+    arena_(arena_)
+}
 
 fn chunk(size: uint) -> @chunk {
     let mut v = ~[];
@@ -15,7 +20,7 @@ fn chunk(size: uint) -> @chunk {
 }
 
 fn arena_with_size(initial_size: uint) -> arena {
-    ret {mut chunks: @cons(chunk(initial_size), @nil)};
+    ret arena_({mut chunks: @cons(chunk(initial_size), @nil)});
 }
 
 fn arena() -> arena {

src/libstd/ebml.rs

@@ -155,7 +155,11 @@ fn doc_as_i32(d: doc) -> i32 { doc_as_u32(d) as i32 }
 fn doc_as_i64(d: doc) -> i64 { doc_as_u64(d) as i64 }
 
 // ebml writing
-type writer = {writer: io::writer, mut size_positions: ~[uint]};
+type writer_ = {writer: io::writer, mut size_positions: ~[uint]};
+
+enum writer {
+    writer_(writer_)
+}
 
 fn write_sized_vuint(w: io::writer, n: uint, size: uint) {
     alt size {
@@ -187,7 +191,7 @@ fn write_vuint(w: io::writer, n: uint) {
 
 fn writer(w: io::writer) -> writer {
     let size_positions: ~[uint] = ~[];
-    ret {writer: w, mut size_positions: size_positions};
+    ret writer_({writer: w, mut size_positions: size_positions});
 }
 
 // FIXME (#2741): Provide a function to write the standard ebml header.
@@ -311,9 +315,12 @@ enum ebml_serializer_tag {
     es_label // Used only when debugging
 }
 
-impl serializer of serialization::serializer for ebml::writer {
-    fn emit_nil() {}
+trait serializer_priv {
+    fn _emit_tagged_uint(t: ebml_serializer_tag, v: uint);
+    fn _emit_label(label: ~str);
+}
 
+impl serializer of serializer_priv for ebml::writer {
     // used internally to emit things like the vector length and so on
     fn _emit_tagged_uint(t: ebml_serializer_tag, v: uint) {
         assert v <= 0xFFFF_FFFF_u;
@@ -329,6 +336,10 @@ impl serializer of serialization::serializer for ebml::writer {
         // try and check failures more quickly.
         if debug { self.wr_tagged_str(es_label as uint, label) }
     }
+}
+
+impl serializer of serialization::serializer for ebml::writer {
+    fn emit_nil() {}
 
     fn emit_uint(v: uint) { self.wr_tagged_u64(es_uint as uint, v as u64); }
     fn emit_u64(v: u64) { self.wr_tagged_u64(es_u64 as uint, v); }
@@ -383,14 +394,18 @@ impl serializer of serialization::serializer for ebml::writer {
     fn emit_tup_elt(_idx: uint, f: fn()) { f() }
 }
 
-type ebml_deserializer = {mut parent: ebml::doc,
-                          mut pos: uint};
+type ebml_deserializer_ = {mut parent: ebml::doc,
+                           mut pos: uint};
+
+enum ebml_deserializer {
+    ebml_deserializer_(ebml_deserializer_)
+}
 
 fn ebml_deserializer(d: ebml::doc) -> ebml_deserializer {
-    {mut parent: d, mut pos: d.start}
+    ebml_deserializer_({mut parent: d, mut pos: d.start})
 }
 
-impl deserializer of serialization::deserializer for ebml_deserializer {
+impl deserializer_priv for ebml_deserializer {
     fn _check_label(lbl: ~str) {
         if self.pos < self.parent.end {
             let {tag: r_tag, doc: r_doc} =
@@ -443,7 +458,9 @@ impl deserializer of serialization::deserializer for ebml_deserializer {
         #debug["_next_uint exp_tag=%? result=%?", exp_tag, r];
         ret r as uint;
     }
+}
 
+impl deserializer of serialization::deserializer for ebml_deserializer {
     fn read_nil() -> () { () }
 
     fn read_u64() -> u64 { ebml::doc_as_u64(self.next_doc(es_u64)) }

src/libstd/json.rs

@@ -8,6 +8,7 @@ import io;
 import io::{reader_util, writer_util};
 import map;
 import map::hashmap;
+import map::map;
 import core::vec::extensions;
 
 export json;
@@ -114,13 +115,17 @@ fn to_str(j: json) -> ~str {
     io::with_str_writer(|wr| to_writer(wr, j))
 }
 
-type parser = {
+type parser_ = {
     rdr: io::reader,
     mut ch: char,
     mut line: uint,
     mut col: uint,
 };
 
+enum parser {
+    parser_(parser_)
+}
+
 impl parser for parser {
     fn eof() -> bool { self.ch == -1 as char }
 
@@ -463,12 +468,12 @@ impl parser for parser {
 
 /// Deserializes a json value from an io::reader
 fn from_reader(rdr: io::reader) -> result<json, error> {
-    let parser = {
+    let parser = parser_({
         rdr: rdr,
         mut ch: rdr.read_char(),
         mut line: 1u,
         mut col: 1u,
-    };
+    });
 
     parser.parse()
 }