---

yaml
---
r: 103590
b: refs/heads/try
c: e5abe66
h: refs/heads/master
v: v3

Author: huonw

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 62f1d68439dcfd509eaca29887afa97f22938373
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6e7f170fedd3c526a643c0b2d13863acd982be02
-refs/heads/try: a97642026c18a624ff6ea01075dd9550f8ed07ff
+refs/heads/try: e5abe669831a59c48faa85e88ed8859b6dc63f49
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/configure

@@ -916,7 +916,6 @@ do
         LLVM_OPTS="$LLVM_OPTS --disable-terminfo"
         # Try to have LLVM pull in as few dependencies as possible (#9397)
         LLVM_OPTS="$LLVM_OPTS --disable-zlib --disable-libffi"
-        LLVM_OPTS="$LLVM_OPTS --disable-compiler-version-checks"
 
         # Use win32 native thread/lock apis instead of pthread wrapper.
         # (llvm's configure tries to find pthread first, so we have to disable it explicitly.)

branches/try/src/etc/gedit/share/gtksourceview-3.0/language-specs/rust.lang

@@ -87,6 +87,7 @@
 		<keyword>f64</keyword>
 		<keyword>char</keyword>
 		<keyword>str</keyword>
+		<keyword>Either</keyword>
 		<keyword>Option</keyword>
 		<keyword>Result</keyword>
     </context>
@@ -133,6 +134,8 @@
 		<keyword>false</keyword>
 		<keyword>Some</keyword>
 		<keyword>None</keyword>
+		<keyword>Left</keyword>
+		<keyword>Right</keyword>
 		<keyword>Ok</keyword>
 		<keyword>Err</keyword>
 		<keyword>Success</keyword>

branches/try/src/etc/generate-deriving-span-tests.py

@@ -86,6 +86,7 @@
 		<item> float </item>
 		<item> char </item>
 		<item> str </item>
+		<item> Either </item>
 		<item> Option </item>
 		<item> Result </item>
 		<item> Self </item>
@@ -130,6 +131,8 @@
 		<item> false </item>
 		<item> Some </item>
 		<item> None </item>
+		<item> Left </item>
+		<item> Right </item>
 		<item> Ok </item>
 		<item> Err </item>
 		<item> Success </item>

branches/try/src/etc/kate/rust.xml

@@ -46,6 +46,8 @@ syn keyword   rustType        f64 i8 i16 i32 i64 str Self
 " to make it easy to update.
 
 " Core operators {{{3
+syn keyword   rustEnum        Either
+syn keyword   rustEnumVariant Left Right
 syn keyword   rustTrait       Sized
 syn keyword   rustTrait       Freeze Send
 syn keyword   rustTrait       Add Sub Mul Div Rem Neg Not
@@ -111,6 +113,7 @@ syn keyword   rustSelf        self
 syn keyword   rustBoolean     true false
 
 syn keyword   rustConstant    Some None       " option
+syn keyword   rustConstant    Left Right      " either
 syn keyword   rustConstant    Ok Err          " result
 syn keyword   rustConstant    Less Equal Greater " Ordering
 

branches/try/src/etc/vim/syntax/rust.vim

@@ -895,7 +895,7 @@ pub fn run_test(force_ignore: bool,
             return;
         }
         StaticBenchFn(benchfn) => {
-            let bs = ::test::bench::benchmark(|harness| benchfn(harness));
+            let bs = ::test::bench::benchmark(benchfn);
             monitor_ch.send((desc, TrBench(bs)));
             return;
         }

branches/try/src/libextra/test.rs

@@ -46,7 +46,6 @@ static KNOWN_FEATURES: &'static [(&'static str, Status)] = &[
     ("phase", Active),
     ("macro_registrar", Active),
     ("log_syntax", Active),
-    ("trace_macros", Active),
 
     // These are used to test this portion of the compiler, they don't actually
     // mean anything
@@ -194,10 +193,6 @@ impl Visitor<()> for Context {
             self.gate_feature("log_syntax", path.span, "`log_syntax!` is not \
                 stable enough for use and is subject to change");
         }
-        else if path.segments.last().unwrap().identifier == self.sess.ident_of("trace_macros") {
-            self.gate_feature("trace_macros", path.span, "`trace_macros` is not \
-                stable enough for use and is subject to change");
-        }
     }
 
     fn visit_ty(&mut self, t: &ast::Ty, _: ()) {

branches/try/src/librustc/front/feature_gate.rs

@@ -176,23 +176,24 @@ pub static tag_link_args_arg: uint = 0x7a;
 
 pub static tag_item_method_tps: uint = 0x7b;
 pub static tag_item_method_fty: uint = 0x7c;
+pub static tag_item_method_transformed_self_ty: uint = 0x7d;
 
-pub static tag_mod_child: uint = 0x7d;
-pub static tag_misc_info: uint = 0x7e;
-pub static tag_misc_info_crate_items: uint = 0x7f;
+pub static tag_mod_child: uint = 0x7e;
+pub static tag_misc_info: uint = 0x7f;
+pub static tag_misc_info_crate_items: uint = 0x80;
 
-pub static tag_item_method_provided_source: uint = 0x80;
-pub static tag_item_impl_vtables: uint = 0x81;
+pub static tag_item_method_provided_source: uint = 0x81;
+pub static tag_item_impl_vtables: uint = 0x82;
 
-pub static tag_impls: uint = 0x82;
-pub static tag_impls_impl: uint = 0x83;
+pub static tag_impls: uint = 0x83;
+pub static tag_impls_impl: uint = 0x84;
 
-pub static tag_items_data_item_inherent_impl: uint = 0x84;
-pub static tag_items_data_item_extension_impl: uint = 0x85;
+pub static tag_items_data_item_inherent_impl: uint = 0x85;
+pub static tag_items_data_item_extension_impl: uint = 0x86;
 
-pub static tag_path_elem_pretty_name: uint = 0x86;
-pub static tag_path_elem_pretty_name_ident: uint = 0x87;
-pub static tag_path_elem_pretty_name_extra: uint = 0x88;
+pub static tag_path_elem_pretty_name: uint = 0x87;
+pub static tag_path_elem_pretty_name_ident: uint = 0x88;
+pub static tag_path_elem_pretty_name_extra: uint = 0x89;
 
 pub static tag_region_param_def: uint = 0x100;
 pub static tag_region_param_def_ident: uint = 0x101;

branches/try/src/librustc/metadata/common.rs

@@ -227,6 +227,16 @@ fn doc_method_fty(doc: ebml::Doc, tcx: ty::ctxt, cdata: Cmd) -> ty::BareFnTy {
                           |_, did| translate_def_id(cdata, did))
 }
 
+fn doc_transformed_self_ty(doc: ebml::Doc,
+                           tcx: ty::ctxt,
+                           cdata: Cmd) -> Option<ty::t>
+{
+    reader::maybe_get_doc(doc, tag_item_method_transformed_self_ty).map(|tp| {
+        parse_ty_data(tp.data, cdata.cnum, tp.start, tcx,
+                      |_, did| translate_def_id(cdata, did))
+    })
+}
+
 pub fn item_type(_item_id: ast::DefId, item: ebml::Doc,
                  tcx: ty::ctxt, cdata: Cmd) -> ty::t {
     doc_type(item, tcx, cdata)
@@ -771,9 +781,9 @@ fn get_explicit_self(item: ebml::Doc) -> ast::ExplicitSelf_ {
     let explicit_self_kind = string[0];
     match explicit_self_kind as char {
         's' => ast::SelfStatic,
-        'v' => ast::SelfValue,
+        'v' => ast::SelfValue(get_mutability(string[1])),
         '@' => ast::SelfBox,
-        '~' => ast::SelfUniq,
+        '~' => ast::SelfUniq(get_mutability(string[1])),
         // FIXME(#4846) expl. region
         '&' => ast::SelfRegion(None, get_mutability(string[1])),
         _ => fail!("unknown self type code: `{}`", explicit_self_kind as char)
@@ -837,6 +847,7 @@ pub fn get_method(intr: @IdentInterner, cdata: Cmd, id: ast::NodeId,
     let type_param_defs = item_ty_param_defs(method_doc, tcx, cdata,
                                              tag_item_method_tps);
     let rp_defs = item_region_param_defs(method_doc, tcx, cdata);
+    let transformed_self_ty = doc_transformed_self_ty(method_doc, tcx, cdata);
     let fty = doc_method_fty(method_doc, tcx, cdata);
     let vis = item_visibility(method_doc);
     let explicit_self = get_explicit_self(method_doc);
@@ -848,6 +859,7 @@ pub fn get_method(intr: @IdentInterner, cdata: Cmd, id: ast::NodeId,
             type_param_defs: type_param_defs,
             region_param_defs: rp_defs,
         },
+        transformed_self_ty,
         fty,
         explicit_self,
         vis,

branches/try/src/librustc/metadata/decoder.rs

@@ -261,6 +261,16 @@ fn encode_type(ecx: &EncodeContext,
     ebml_w.end_tag();
 }
 
+fn encode_transformed_self_ty(ecx: &EncodeContext,
+                              ebml_w: &mut writer::Encoder,
+                              opt_typ: Option<ty::t>) {
+    for &typ in opt_typ.iter() {
+        ebml_w.start_tag(tag_item_method_transformed_self_ty);
+        write_type(ecx, ebml_w, typ);
+        ebml_w.end_tag();
+    }
+}
+
 fn encode_method_fty(ecx: &EncodeContext,
                      ebml_w: &mut writer::Encoder,
                      typ: &ty::BareFnTy) {
@@ -669,13 +679,23 @@ fn encode_explicit_self(ebml_w: &mut writer::Encoder, explicit_self: ast::Explic
 
     // Encode the base self type.
     match explicit_self {
-        SelfStatic => ebml_w.writer.write(&[ 's' as u8 ]),
-        SelfValue  => ebml_w.writer.write(&[ 'v' as u8 ]),
-        SelfBox    => ebml_w.writer.write(&[ '@' as u8 ]),
-        SelfUniq   => ebml_w.writer.write(&[ '~' as u8 ]),
+        SelfStatic => {
+            ebml_w.writer.write(&[ 's' as u8 ]);
+        }
+        SelfValue(m) => {
+            ebml_w.writer.write(&[ 'v' as u8 ]);
+            encode_mutability(ebml_w, m);
+        }
         SelfRegion(_, m) => {
             // FIXME(#4846) encode custom lifetime
-            ebml_w.writer.write(&['&' as u8]);
+            ebml_w.writer.write(&[ '&' as u8 ]);
+            encode_mutability(ebml_w, m);
+        }
+        SelfBox => {
+            ebml_w.writer.write(&[ '@' as u8 ]);
+        }
+        SelfUniq(m) => {
+            ebml_w.writer.write(&[ '~' as u8 ]);
             encode_mutability(ebml_w, m);
         }
     }
@@ -787,6 +807,7 @@ fn encode_method_ty_fields(ecx: &EncodeContext,
     encode_ty_type_param_defs(ebml_w, ecx,
                               method_ty.generics.type_param_defs,
                               tag_item_method_tps);
+    encode_transformed_self_ty(ecx, ebml_w, method_ty.transformed_self_ty);
     encode_method_fty(ecx, ebml_w, &method_ty.fty);
     encode_visibility(ebml_w, method_ty.vis);
     encode_explicit_self(ebml_w, method_ty.explicit_self);

branches/try/src/librustc/metadata/encoder.rs

@@ -374,6 +374,10 @@ fn parse_ty(st: &mut PState, conv: conv_did) -> ty::t {
         return ty::mk_bare_fn(st.tcx, parse_bare_fn_ty(st, |x,y| conv(x,y)));
       }
       'Y' => return ty::mk_type(st.tcx),
+      'C' => {
+        let sigil = parse_sigil(st);
+        return ty::mk_opaque_closure_ptr(st.tcx, sigil);
+      }
       '#' => {
         let pos = parse_hex(st);
         assert_eq!(next(st), ':');

branches/try/src/librustc/metadata/tydecode.rs

@@ -327,6 +327,10 @@ fn enc_sty(w: &mut MemWriter, cx: @ctxt, st: &ty::sty) {
             mywrite!(w, "s{}|", (cx.ds)(did));
         }
         ty::ty_type => mywrite!(w, "Y"),
+        ty::ty_opaque_closure_ptr(p) => {
+            mywrite!(w, "C&");
+            enc_sigil(w, p);
+        }
         ty::ty_struct(def, ref substs) => {
             mywrite!(w, "a[{}|", (cx.ds)(def));
             enc_substs(w, cx, substs);