---

yaml
---
r: 31479
b: refs/heads/dist-snap
c: 93c2f5e
h: refs/heads/master
i:
  31477: d7654a6
  31475: 776041d
  31471: fe72d02
v: v3

Author: pcwalton

[refs]

@@ -7,6 +7,6 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
 refs/heads/incoming: d9317a174e434d4c99fc1a37fd7dc0d2f5328d37
-refs/heads/dist-snap: e6d2e49852873c52b872185a0ae5a8ca941ed2f1
+refs/heads/dist-snap: 93c2f5e0e43532a2288ed6dec378564264d1a77c
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/dist-snap/src/libcore/core.rs

@@ -31,7 +31,8 @@ import f32::num;
 import f64::num;
 import num::num;
 import ops::{const, copy, send, owned};
-import ops::{add, sub, mul, div, modulo, neg, bitops, index};
+import ops::{add, sub, mul, div, modulo, neg, bitand, bitor, bitxor, shl};
+import ops::{shr, index};
 
 export path, option, some, none, unreachable;
 export extensions;

branches/dist-snap/src/libcore/ops.rs

@@ -1,64 +1,96 @@
 // Core operators and kinds.
 
+#[cfg(notest)]
 #[lang="const"]
 trait const {
     // Empty.
 }
 
+#[cfg(notest)]
 #[lang="copy"]
 trait copy {
     // Empty.
 }
 
+#[cfg(notest)]
 #[lang="send"]
 trait send {
     // Empty.
 }
 
+#[cfg(notest)]
 #[lang="owned"]
 trait owned {
     // Empty.
 }
 
+#[cfg(notest)]
 #[lang="add"]
 trait add<RHS,Result> {
     pure fn add(rhs: RHS) -> Result;
 }
 
+#[cfg(notest)]
 #[lang="sub"]
 trait sub<RHS,Result> {
     pure fn sub(rhs: RHS) -> Result;
 }
 
+#[cfg(notest)]
 #[lang="mul"]
 trait mul<RHS,Result> {
     pure fn mul(rhs: RHS) -> Result;
 }
 
+#[cfg(notest)]
 #[lang="div"]
 trait div<RHS,Result> {
     pure fn div(rhs: RHS) -> Result;
 }
 
+#[cfg(notest)]
 #[lang="modulo"]
 trait modulo<RHS,Result> {
     pure fn modulo(rhs: RHS) -> Result;
 }
 
+#[cfg(notest)]
 #[lang="neg"]
-trait neg<RHS,Result> {
-    pure fn neg(rhs: RHS) -> Result;
+trait neg<Result> {
+    pure fn neg() -> Result;
 }
 
-#[lang="bitops"]
-trait bitops<RHS,BitCount,Result> {
-    pure fn and(rhs: RHS) -> Result;
-    pure fn or(rhs: RHS) -> Result;
-    pure fn xor(rhs: RHS) -> Result;
-    pure fn shl(n: BitCount) -> Result;
-    pure fn shr(n: BitCount) -> Result;
+#[cfg(notest)]
+#[lang="bitand"]
+trait bitand<RHS,Result> {
+    pure fn bitand(rhs: RHS) -> Result;
 }
 
+#[cfg(notest)]
+#[lang="bitor"]
+trait bitor<RHS,Result> {
+    pure fn bitor(rhs: RHS) -> Result;
+}
+
+#[cfg(notest)]
+#[lang="bitxor"]
+trait bitxor<RHS,Result> {
+    pure fn bitxor(rhs: RHS) -> Result;
+}
+
+#[cfg(notest)]
+#[lang="shl"]
+trait shl<RHS,Result> {
+    pure fn shl(rhs: RHS) -> Result;
+}
+
+#[cfg(notest)]
+#[lang="shr"]
+trait shr<RHS,Result> {
+    pure fn shr(rhs: RHS) -> Result;
+}
+
+#[cfg(notest)]
 #[lang="index"]
 trait index<Index,Result> {
     pure fn index(index: Index) -> Result;

branches/dist-snap/src/libstd/ebml.rs

@@ -27,6 +27,8 @@ export serializer;
 export ebml_deserializer;
 export deserializer;
 export with_doc_data;
+export get_doc;
+export extensions;
 
 type ebml_tag = {id: uint, size: uint};
 
@@ -40,6 +42,24 @@ type doc = {data: @~[u8], start: uint, end: uint};
 
 type tagged_doc = {tag: uint, doc: doc};
 
+trait get_doc {
+    fn [](tag: uint) -> doc;
+}
+
+impl extensions of get_doc for doc {
+    fn [](tag: uint) -> doc {
+        get_doc(self, tag)
+    }
+}
+
+impl extensions of ops::index<uint,doc> for doc {
+    pure fn index(&&tag: uint) -> doc {
+        unchecked {
+            get_doc(self, tag)
+        }
+    }
+}
+
 fn vuint_at(data: &[u8], start: uint) -> {val: uint, next: uint} {
     let a = data[start];
     if a & 0x80u8 != 0u8 {

branches/dist-snap/src/libsyntax/ast.rs

@@ -773,6 +773,59 @@ enum inlined_item {
     ii_dtor(class_dtor, ident, ~[ty_param], def_id /* parent id */)
 }
 
+// Convenience functions
+
+pure fn simple_path(id: ident, span: span) -> @path {
+    @{span: span,
+      global: false,
+      idents: ~[id],
+      rp: none,
+      types: ~[]}
+}
+
+pure fn empty_span() -> span {
+    {lo: 0, hi: 0, expn_info: none}
+}
+
+// Convenience implementations
+
+// Remove after snapshot!
+trait path_concat {
+    pure fn +(&&id: ident) -> @path;
+}
+
+// Remove after snapshot!
+impl methods of path_concat for ident {
+    pure fn +(&&id: ident) -> @path {
+        simple_path(self, empty_span()) + id
+    }
+}
+
+impl methods of ops::add<ident,@path> for ident {
+    pure fn add(&&id: ident) -> @path {
+        simple_path(self, empty_span()) + id
+    }
+}
+
+// Remove after snapshot!
+impl methods of path_concat for @path {
+    pure fn +(&&id: ident) -> @path {
+        @{
+            idents: vec::append_one(self.idents, id)
+            with *self
+        }
+    }
+}
+
+impl methods of ops::add<ident,@path> for @path {
+    pure fn add(&&id: ident) -> @path {
+        @{
+            idents: vec::append_one(self.idents, id)
+            with *self
+        }
+    }
+}
+
 //
 // Local Variables:
 // mode: rust

branches/dist-snap/src/libsyntax/ast_util.rs

@@ -87,6 +87,22 @@ pure fn binop_to_str(op: binop) -> ~str {
     }
 }
 
+pure fn binop_to_method_name(op: binop) -> option<~str> {
+    alt op {
+      add { ret some(~"add"); }
+      subtract { ret some(~"sub"); }
+      mul { ret some(~"mul"); }
+      div { ret some(~"div"); }
+      rem { ret some(~"modulo"); }
+      bitxor { ret some(~"bitxor"); }
+      bitand { ret some(~"bitand"); }
+      bitor { ret some(~"bitor"); }
+      shl { ret some(~"shl"); }
+      shr { ret some(~"shr"); }
+      and | or | eq | lt | le | ne | ge | gt { ret none; }
+    }
+}
+
 pure fn lazy_binop(b: binop) -> bool {
     alt b { and { true } or { true } _ { false } }
 }

branches/dist-snap/src/libsyntax/ext/pipes/ast_builder.rs

@@ -31,23 +31,6 @@ fn empty_span() -> span {
     {lo: 0, hi: 0, expn_info: none}
 }
 
-trait path_concat {
-    fn +(id: ident) -> @ast::path;
-}
-
-impl methods of path_concat for ident {
-    fn +(id: ident) -> @ast::path {
-        path(self, empty_span()) + id
-    }
-}
-
-impl methods of path_concat for @ast::path {
-    fn +(id: ident) -> @ast::path {
-        @{idents: vec::append_one(self.idents, id)
-          with *self}
-    }
-}
-
 trait append_types {
     fn add_ty(ty: @ast::ty) -> @ast::path;
     fn add_tys(+tys: ~[@ast::ty]) -> @ast::path;

branches/dist-snap/src/libsyntax/ext/pipes/pipec.rs

@@ -16,12 +16,12 @@ import ext::base::{mk_ctxt, ext_ctxt};
 import parse;
 import parse::*;
 import proto::*;
+import ast::methods;
 
 import ast_builder::append_types;
 import ast_builder::ast_builder;
 import ast_builder::methods;
 import ast_builder::path;
-import ast_builder::path_concat;
 
 // Transitional reexports so qquote can find the paths it is looking for
 mod syntax {

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

@@ -170,15 +170,15 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg,
                              session::sess_os_to_meta_os(sess.targ_cfg.os),
                              sess.opts.static));
 
-    time(time_passes, ~"language item collection", ||
+    let lang_items = time(time_passes, ~"language item collection", ||
          middle::lang_items::collect_language_items(crate, sess));
 
     let { def_map: def_map,
           exp_map: exp_map,
           impl_map: impl_map,
           trait_map: trait_map } =
         time(time_passes, ~"resolution", ||
-             middle::resolve3::resolve_crate(sess, ast_map, crate));
+             middle::resolve3::resolve_crate(sess, lang_items, crate));
 
     let freevars = time(time_passes, ~"freevar finding", ||
         freevars::annotate_freevars(def_map, crate));

branches/dist-snap/src/rustc/middle/astencode.rs

@@ -13,6 +13,8 @@ import std::ebml;
 import std::ebml::writer;
 import std::ebml::serializer;
 import std::ebml::deserializer;
+import std::ebml::extensions;
+import std::ebml::get_doc;
 import std::map::hashmap;
 import std::serialization::serializer;
 import std::serialization::deserializer;
@@ -285,7 +287,7 @@ fn simplify_ast(ii: ast::inlined_item) -> ast::inlined_item {
 }
 
 fn decode_ast(par_doc: ebml::doc) -> ast::inlined_item {
-    let chi_doc = par_doc[c::tag_tree];
+    let chi_doc = par_doc[c::tag_tree as uint];
     let d = ebml::ebml_deserializer(chi_doc);
     ast::deserialize_inlined_item(d)
 }
@@ -776,15 +778,11 @@ fn encode_side_tables_for_id(ecx: @e::encode_ctxt,
 
 trait doc_decoder_helpers {
     fn as_int() -> int;
-    fn [](tag: c::astencode_tag) -> ebml::doc;
     fn opt_child(tag: c::astencode_tag) -> option<ebml::doc>;
 }
 
 impl decoder of doc_decoder_helpers for ebml::doc {
     fn as_int() -> int { ebml::doc_as_u64(self) as int }
-    fn [](tag: c::astencode_tag) -> ebml::doc {
-        ebml::get_doc(self, tag as uint)
-    }
     fn opt_child(tag: c::astencode_tag) -> option<ebml::doc> {
         ebml::maybe_get_doc(self, tag as uint)
     }
@@ -843,9 +841,9 @@ impl decoder of ebml_deserializer_decoder_helpers
 fn decode_side_tables(xcx: extended_decode_ctxt,
                       ast_doc: ebml::doc) {
     let dcx = xcx.dcx;
-    let tbl_doc = ast_doc[c::tag_table];
+    let tbl_doc = ast_doc[c::tag_table as uint];
     for ebml::docs(tbl_doc) |tag, entry_doc| {
-        let id0 = entry_doc[c::tag_table_id].as_int();
+        let id0 = entry_doc[c::tag_table_id as uint].as_int();
         let id = xcx.tr_id(id0);
 
         #debug[">> Side table document with tag 0x%x \
@@ -855,7 +853,7 @@ fn decode_side_tables(xcx: extended_decode_ctxt,
         if tag == (c::tag_table_mutbl as uint) {
             dcx.maps.mutbl_map.insert(id, ());
         } else {
-            let val_doc = entry_doc[c::tag_table_val];
+            let val_doc = entry_doc[c::tag_table_val as uint];
             let val_dsr = ebml::ebml_deserializer(val_doc);
             if tag == (c::tag_table_def as uint) {
                 let def = decode_def(xcx, val_doc);
@@ -916,7 +914,7 @@ fn encode_item_ast(ebml_w: ebml::writer, item: @ast::item) {
 
 #[cfg(test)]
 fn decode_item_ast(par_doc: ebml::doc) -> @ast::item {
-    let chi_doc = par_doc[c::tag_tree];
+    let chi_doc = par_doc[c::tag_tree as uint];
     let d = ebml::ebml_deserializer(chi_doc);
     @ast::deserialize_item(d)
 }