---

yaml
---
r: 150843
b: refs/heads/try2
c: 7c042cd
h: refs/heads/master
i:
  150841: ca18efa
  150839: 69a2895
v: v3

Author: michaelwoerister

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 72869b6579154d7aa322ddd0f9e3d89fd8abe8c4
+refs/heads/try2: 7c042cd70b9528051a1a1abba9e5d18657550306
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/doc/rust.md

@@ -1586,10 +1586,10 @@ pub struct Bar {
     field: int
 }
 
-// Declare a public enum with two public variants
+// Declare a public enum with public and private variants
 pub enum State {
     PubliclyAccessibleState,
-    PubliclyAccessibleState2,
+    priv PrivatelyAccessibleState
 }
 ~~~~
 

branches/try2/src/libfourcc/lib.rs

@@ -57,7 +57,7 @@ use syntax::ast::Name;
 use syntax::attr::contains;
 use syntax::codemap::{Span, mk_sp};
 use syntax::ext::base;
-use syntax::ext::base::{SyntaxExtension, BasicMacroExpander, NormalTT, ExtCtxt, MacExpr};
+use syntax::ext::base::{SyntaxExtension, BasicMacroExpander, NormalTT, ExtCtxt, MRExpr};
 use syntax::ext::build::AstBuilder;
 use syntax::parse;
 use syntax::parse::token;
@@ -73,7 +73,7 @@ pub fn macro_registrar(register: |Name, SyntaxExtension|) {
         None));
 }
 
-pub fn expand_syntax_ext(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) -> ~base::MacResult {
+pub fn expand_syntax_ext(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) -> base::MacResult {
     let (expr, endian) = parse_tts(cx, tts);
 
     let little = match endian {
@@ -101,12 +101,12 @@ pub fn expand_syntax_ext(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) ->
             }
             _ => {
                 cx.span_err(expr.span, "unsupported literal in fourcc!");
-                return base::DummyResult::expr(sp)
+                return MRExpr(cx.expr_lit(sp, ast::LitUint(0u64, ast::TyU32)));
             }
         },
         _ => {
             cx.span_err(expr.span, "non-literal in fourcc!");
-            return base::DummyResult::expr(sp)
+            return MRExpr(cx.expr_lit(sp, ast::LitUint(0u64, ast::TyU32)));
         }
     };
 
@@ -126,7 +126,7 @@ pub fn expand_syntax_ext(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) ->
         };
     }
     let e = cx.expr_lit(sp, ast::LitUint(val as u64, ast::TyU32));
-    MacExpr::new(e)
+    MRExpr(e)
 }
 
 struct Ident {

branches/try2/src/libhexfloat/lib.rs

@@ -53,7 +53,7 @@ use syntax::ast;
 use syntax::ast::Name;
 use syntax::codemap::{Span, mk_sp};
 use syntax::ext::base;
-use syntax::ext::base::{SyntaxExtension, BasicMacroExpander, NormalTT, ExtCtxt, MacExpr};
+use syntax::ext::base::{SyntaxExtension, BasicMacroExpander, NormalTT, ExtCtxt, MRExpr};
 use syntax::ext::build::AstBuilder;
 use syntax::parse;
 use syntax::parse::token;
@@ -97,7 +97,7 @@ fn hex_float_lit_err(s: &str) -> Option<(uint, ~str)> {
     }
 }
 
-pub fn expand_syntax_ext(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) -> ~base::MacResult {
+pub fn expand_syntax_ext(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) -> base::MacResult {
     let (expr, ty_lit) = parse_tts(cx, tts);
 
     let ty = match ty_lit {
@@ -121,12 +121,12 @@ pub fn expand_syntax_ext(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) ->
             }
             _ => {
                 cx.span_err(expr.span, "unsupported literal in hexfloat!");
-                return base::DummyResult::expr(sp);
+                return base::MacResult::dummy_expr(sp);
             }
         },
         _ => {
             cx.span_err(expr.span, "non-literal in hexfloat!");
-            return base::DummyResult::expr(sp);
+            return base::MacResult::dummy_expr(sp);
         }
     };
 
@@ -137,7 +137,7 @@ pub fn expand_syntax_ext(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) ->
                 let pos = expr.span.lo + syntax::codemap::Pos::from_uint(err_pos + 1);
                 let span = syntax::codemap::mk_sp(pos,pos);
                 cx.span_err(span, format!("invalid hex float literal in hexfloat!: {}", err_str));
-                return base::DummyResult::expr(sp);
+                return base::MacResult::dummy_expr(sp);
             }
             _ => ()
         }
@@ -147,7 +147,7 @@ pub fn expand_syntax_ext(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) ->
         None => ast::LitFloatUnsuffixed(s),
         Some (ty) => ast::LitFloat(s, ty)
     };
-    MacExpr::new(cx.expr_lit(sp, lit))
+    MRExpr(cx.expr_lit(sp, lit))
 }
 
 struct Ident {

branches/try2/src/liblibc/lib.rs

@@ -229,8 +229,8 @@ pub mod types {
             */
             #[repr(u8)]
             pub enum c_void {
-                __variant1,
-                __variant2,
+                priv variant1,
+                priv variant2
             }
             pub enum FILE {}
             pub enum fpos_t {}

branches/try2/src/librand/distributions/gamma.rs

@@ -45,14 +45,10 @@ use super::{IndependentSample, Sample, Exp};
 /// for Generating Gamma Variables" *ACM Trans. Math. Softw.* 26, 3
 /// (September 2000),
 /// 363-372. DOI:[10.1145/358407.358414](http://doi.acm.org/10.1145/358407.358414)
-pub struct Gamma {
-    repr: GammaRepr,
-}
-
-enum GammaRepr {
-    Large(GammaLargeShape),
-    One(Exp),
-    Small(GammaSmallShape)
+pub enum Gamma {
+    priv Large(GammaLargeShape),
+    priv One(Exp),
+    priv Small(GammaSmallShape)
 }
 
 // These two helpers could be made public, but saving the
@@ -94,12 +90,11 @@ impl Gamma {
         assert!(shape > 0.0, "Gamma::new called with shape <= 0");
         assert!(scale > 0.0, "Gamma::new called with scale <= 0");
 
-        let repr = match shape {
+        match shape {
             1.0        => One(Exp::new(1.0 / scale)),
             0.0 .. 1.0 => Small(GammaSmallShape::new_raw(shape, scale)),
             _          => Large(GammaLargeShape::new_raw(shape, scale))
-        };
-        Gamma { repr: repr }
+        }
     }
 }
 
@@ -136,7 +131,7 @@ impl Sample<f64> for GammaLargeShape {
 
 impl IndependentSample<f64> for Gamma {
     fn ind_sample<R: Rng>(&self, rng: &mut R) -> f64 {
-        match self.repr {
+        match *self {
             Small(ref g) => g.ind_sample(rng),
             One(ref g) => g.ind_sample(rng),
             Large(ref g) => g.ind_sample(rng),
@@ -188,37 +183,32 @@ impl IndependentSample<f64> for GammaLargeShape {
 /// let v = chi.ind_sample(&mut rand::task_rng());
 /// println!("{} is from a χ²(11) distribution", v)
 /// ```
-pub struct ChiSquared {
-    repr: ChiSquaredRepr,
-}
-
-enum ChiSquaredRepr {
+pub enum ChiSquared {
     // k == 1, Gamma(alpha, ..) is particularly slow for alpha < 1,
     // e.g. when alpha = 1/2 as it would be for this case, so special-
     // casing and using the definition of N(0,1)^2 is faster.
-    DoFExactlyOne,
-    DoFAnythingElse(Gamma),
+    priv DoFExactlyOne,
+    priv DoFAnythingElse(Gamma)
 }
 
 impl ChiSquared {
     /// Create a new chi-squared distribution with degrees-of-freedom
     /// `k`. Fails if `k < 0`.
     pub fn new(k: f64) -> ChiSquared {
-        let repr = if k == 1.0 {
+        if k == 1.0 {
             DoFExactlyOne
         } else {
             assert!(k > 0.0, "ChiSquared::new called with `k` < 0");
             DoFAnythingElse(Gamma::new(0.5 * k, 2.0))
-        };
-        ChiSquared { repr: repr }
+        }
     }
 }
 impl Sample<f64> for ChiSquared {
     fn sample<R: Rng>(&mut self, rng: &mut R) -> f64 { self.ind_sample(rng) }
 }
 impl IndependentSample<f64> for ChiSquared {
     fn ind_sample<R: Rng>(&self, rng: &mut R) -> f64 {
-        match self.repr {
+        match *self {
             DoFExactlyOne => {
                 // k == 1 => N(0,1)^2
                 let StandardNormal(norm) = rng.gen::<StandardNormal>();

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

@@ -124,6 +124,7 @@ enum Family {
     Trait,                 // I
     Struct,                // S
     PublicField,           // g
+    PrivateField,          // j
     InheritedField         // N
 }
 
@@ -148,6 +149,7 @@ fn item_family(item: ebml::Doc) -> Family {
       'I' => Trait,
       'S' => Struct,
       'g' => PublicField,
+      'j' => PrivateField,
       'N' => InheritedField,
        c => fail!("unexpected family char: {}", c)
     }
@@ -159,6 +161,7 @@ fn item_visibility(item: ebml::Doc) -> ast::Visibility {
         Some(visibility_doc) => {
             match reader::doc_as_u8(visibility_doc) as char {
                 'y' => ast::Public,
+                'n' => ast::Private,
                 'i' => ast::Inherited,
                 _ => fail!("unknown visibility character")
             }
@@ -361,7 +364,7 @@ fn item_to_def_like(item: ebml::Doc, did: ast::DefId, cnum: ast::CrateNum)
         Trait => DlDef(ast::DefTrait(did)),
         Enum => DlDef(ast::DefTy(did)),
         Impl => DlImpl(did),
-        PublicField | InheritedField => DlField,
+        PublicField | PrivateField | InheritedField => DlField,
     }
 }
 
@@ -959,6 +962,7 @@ pub fn get_item_attrs(cdata: Cmd,
 fn struct_field_family_to_visibility(family: Family) -> ast::Visibility {
     match family {
       PublicField => ast::Public,
+      PrivateField => ast::Private,
       InheritedField => ast::Inherited,
       _ => fail!()
     }
@@ -971,7 +975,7 @@ pub fn get_struct_fields(intr: Rc<IdentInterner>, cdata: Cmd, id: ast::NodeId)
     let mut result = Vec::new();
     reader::tagged_docs(item, tag_item_field, |an_item| {
         let f = item_family(an_item);
-        if f == PublicField || f == InheritedField {
+        if f == PublicField || f == PrivateField || f == InheritedField {
             // FIXME #6993: name should be of type Name, not Ident
             let name = item_name(&*intr, an_item);
             let did = item_def_id(an_item, cdata);

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

@@ -607,6 +607,7 @@ fn encode_struct_field_family(ebml_w: &mut Encoder,
                               visibility: Visibility) {
     encode_family(ebml_w, match visibility {
         Public => 'g',
+        Private => 'j',
         Inherited => 'N'
     });
 }
@@ -615,6 +616,7 @@ fn encode_visibility(ebml_w: &mut Encoder, visibility: Visibility) {
     ebml_w.start_tag(tag_items_data_item_visibility);
     let ch = match visibility {
         Public => 'y',
+        Private => 'n',
         Inherited => 'i',
     };
     ebml_w.wr_str(str::from_char(ch));