---

yaml
---
r: 44990
b: refs/heads/master
c: 7782aa8
h: refs/heads/master
v: v3

Author: thestinger

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 704cd648ac1160c5f02291e505697a6cf7e20945
+refs/heads/master: 7782aa82d2238371f8d62ed8122d05c2cc225317
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d9689399d091c3265f00434a69c551a61c28dc
 refs/heads/try: ef355f6332f83371e4acf04fc4eb940ab41d78d3

trunk/src/libcore/bool.rs

@@ -12,6 +12,8 @@
 //! Boolean logic
 
 use option::{None, Option, Some};
+use from_str::FromStr;
+
 #[cfg(notest)] use cmp;
 
 /// Negation / inverse
@@ -46,13 +48,15 @@ pub pure fn is_true(v: bool) -> bool { v }
 pub pure fn is_false(v: bool) -> bool { !v }
 
 /// Parse logic value from `s`
-pub pure fn from_str(s: &str) -> Option<bool> {
-    if s == "true" {
-        Some(true)
-    } else if s == "false" {
-        Some(false)
-    } else {
-        None
+impl FromStr for bool {
+    static pure fn from_str(s: &str) -> Option<bool> {
+        if s == "true" {
+            Some(true)
+        } else if s == "false" {
+            Some(false)
+        } else {
+            None
+        }
     }
 }
 
@@ -79,8 +83,10 @@ impl cmp::Eq for bool {
 
 #[test]
 pub fn test_bool_from_str() {
+    use from_str::FromStr;
+
     do all_values |v| {
-        assert Some(v) == from_str(to_str(v))
+        assert Some(v) == FromStr::from_str(to_str(v))
     }
 }
 

trunk/src/libcore/from_str.rs

@@ -15,4 +15,3 @@ use option::Option;
 pub trait FromStr {
     static pure fn from_str(s: &str) -> Option<Self>;
 }
-

trunk/src/librustc/front/test.rs

@@ -178,14 +178,12 @@ fn is_test_fn(i: @ast::item) -> bool {
 
     fn has_test_signature(i: @ast::item) -> bool {
         match &i.node {
-          &ast::item_fn(ref decl, _, ref generics, _) => {
+          &ast::item_fn(ref decl, _, ref tps, _) => {
             let no_output = match decl.output.node {
                 ast::ty_nil => true,
                 _ => false
             };
-            decl.inputs.is_empty()
-                && no_output
-                && !generics.is_parameterized()
+            decl.inputs.is_empty() && no_output && tps.is_empty()
           }
           _ => false
         }

trunk/src/librustc/metadata/encoder.rs

@@ -228,16 +228,14 @@ fn encode_type(ecx: @EncodeContext, ebml_w: writer::Encoder, typ: ty::t) {
 
 fn encode_symbol(ecx: @EncodeContext, ebml_w: writer::Encoder, id: node_id) {
     ebml_w.start_tag(tag_items_data_item_symbol);
-    match ecx.item_symbols.find(&id) {
-        Some(ref x) => {
-            debug!("encode_symbol(id=%?, str=%s)", id, *x);
-            ebml_w.writer.write(str::to_bytes(*x));
-        }
-        None => {
-            ecx.diag.handler().bug(
-                fmt!("encode_symbol: id not found %d", id));
-        }
-    }
+    let sym = match ecx.item_symbols.find(&id) {
+      Some(ref x) => (/*bad*/copy *x),
+      None => {
+        ecx.diag.handler().bug(
+            fmt!("encode_symbol: id not found %d", id));
+      }
+    };
+    ebml_w.writer.write(str::to_bytes(sym));
     ebml_w.end_tag();
 }
 
@@ -266,8 +264,6 @@ fn encode_enum_variant_info(ecx: @EncodeContext, ebml_w: writer::Encoder,
                             path: &[ast_map::path_elt],
                             index: @mut ~[entry<int>],
                             generics: &ast::Generics) {
-    debug!("encode_enum_variant_info(id=%?)", id);
-
     let mut disr_val = 0;
     let mut i = 0;
     let vi = ty::enum_variants(ecx.tcx,

trunk/src/librustc/middle/trans/base.rs

@@ -2079,15 +2079,15 @@ pub fn trans_item(ccx: @CrateContext, item: ast::item) {
         _ => fail!(~"trans_item"),
     };
     match /*bad*/copy item.node {
-      ast::item_fn(ref decl, purity, ref generics, ref body) => {
+      ast::item_fn(ref decl, purity, ref tps, ref body) => {
         if purity == ast::extern_fn  {
             let llfndecl = get_item_val(ccx, item.id);
             foreign::trans_foreign_fn(ccx,
                                      vec::append(
                                          /*bad*/copy *path,
                                          ~[path_name(item.ident)]),
                                       decl, body, llfndecl, item.id);
-        } else if !generics.is_type_parameterized() {
+        } else if tps.is_empty() {
             let llfndecl = get_item_val(ccx, item.id);
             trans_fn(ccx,
                      vec::append(/*bad*/copy *path, ~[path_name(item.ident)]),
@@ -2111,8 +2111,8 @@ pub fn trans_item(ccx: @CrateContext, item: ast::item) {
       ast::item_mod(ref m) => {
         trans_mod(ccx, m);
       }
-      ast::item_enum(ref enum_definition, ref generics) => {
-        if !generics.is_type_parameterized() {
+      ast::item_enum(ref enum_definition, ref tps) => {
+        if tps.is_empty() {
             let degen = (*enum_definition).variants.len() == 1u;
             let vi = ty::enum_variants(ccx.tcx, local_def(item.id));
             let mut i = 0;
@@ -2128,8 +2128,8 @@ pub fn trans_item(ccx: @CrateContext, item: ast::item) {
         };
         foreign::trans_foreign_mod(ccx, foreign_mod, abi);
       }
-      ast::item_struct(struct_def, generics) => {
-        if !generics.is_type_parameterized() {
+      ast::item_struct(struct_def, tps) => {
+        if tps.is_empty() {
             trans_struct_def(ccx, struct_def, path, item.id);
         }
       }

trunk/src/librustc/middle/typeck/collect.rs

@@ -861,7 +861,7 @@ pub fn ty_of_item(ccx: &CrateCtxt, it: @ast::item)
                 // like "foo<X>".  This is because otherwise ty_to_str will
                 // print the name as merely "foo", as it has no way to
                 // reconstruct the value of X.
-                if generics.is_parameterized() { t0 } else {
+                if !generics.is_empty() { t0 } else {
                     ty::mk_with_id(tcx, t0, def_id)
                 }
             };

trunk/src/librustc/middle/typeck/mod.rs

@@ -315,7 +315,7 @@ fn check_main_fn_ty(ccx: @mut CrateCtxt,
                 Some(ast_map::node_item(it,_)) => {
                     match it.node {
                         ast::item_fn(_, _, ref ps, _)
-                        if ps.is_parameterized() => {
+                        if !ps.is_empty() => {
                             tcx.sess.span_err(
                                 main_span,
                                 ~"main function is not allowed \

trunk/src/libsyntax/ast.rs

@@ -161,14 +161,8 @@ pub struct Generics {
 }
 
 pub impl Generics {
-    fn is_parameterized(&self) -> bool {
-        self.lifetimes.len() + self.ty_params.len() > 0
-    }
-    fn is_lt_parameterized(&self) -> bool {
-        self.lifetimes.len() > 0
-    }
-    fn is_type_parameterized(&self) -> bool {
-        self.ty_params.len() > 0
+    fn is_empty(&self) -> bool {
+        self.lifetimes.len() + self.ty_params.len() == 0
     }
 }
 

trunk/src/libsyntax/print/pprust.rs

@@ -567,7 +567,7 @@ pub fn print_item(s: @ps, &&item: @ast::item) {
 
       ast::item_impl(ref generics, opt_trait, ty, ref methods) => {
         head(s, visibility_qualified(item.vis, ~"impl"));
-        if generics.is_parameterized() {
+        if !generics.is_empty() {
             print_generics(s, generics);
             space(s.s);
         }