---

yaml
---
r: 39798
b: refs/heads/incoming
c: 4c441e9
h: refs/heads/master
v: v3

Author: catamorphism

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 3d5418789064fdb463e872a4e651af1c628a3650
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278
-refs/heads/incoming: ea937dca8995311c6ee8d73e0c45dab3d4c1a4f4
+refs/heads/incoming: 4c441e95d69909265e69cffd3439f890914e02b3
 refs/heads/dist-snap: 22efa39382d41b084fde1719df7ae8ce5697d8c9
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/src/libcore/core.rc

@@ -172,7 +172,7 @@ pub mod util;
 
 pub use kinds::{Const, Copy, Owned, Durable};
 pub use ops::{Drop};
-pub use ops::{Add, Sub, Mul, Div, Modulo, Neg, Not};
+pub use ops::{Add, Sub, Mul, Div, Modulo, Neg};
 pub use ops::{BitAnd, BitOr, BitXor};
 pub use ops::{Shl, Shr, Index};
 

branches/incoming/src/libcore/ops.rs

@@ -48,11 +48,6 @@ pub trait Neg<Result> {
     pure fn neg(&self) -> Result;
 }
 
-#[lang="not"]
-pub trait Not<Result> {
-    pure fn not(&self) -> Result;
-}
-
 #[lang="bitand"]
 pub trait BitAnd<RHS,Result> {
     pure fn bitand(&self, rhs: &RHS) -> Result;
@@ -82,3 +77,4 @@ pub trait Shr<RHS,Result> {
 pub trait Index<Index,Result> {
     pure fn index(&self, index: Index) -> Result;
 }
+

branches/incoming/src/libcore/prelude.rs

@@ -4,7 +4,7 @@
 
 pub use kinds::{Const, Copy, Owned, Durable};
 pub use ops::{Drop};
-pub use ops::{Add, Sub, Mul, Div, Modulo, Neg, Not};
+pub use ops::{Add, Sub, Mul, Div, Modulo, Neg};
 pub use ops::{BitAnd, BitOr, BitXor};
 pub use ops::{Shl, Shr, Index};
 pub use option::{Option, Some, None};

branches/incoming/src/librustc/middle/lang_items.rs

@@ -50,37 +50,36 @@ pub enum LangItem {
     DivTraitLangItem,           // 8
     ModuloTraitLangItem,        // 9
     NegTraitLangItem,           // 10
-    NotTraitLangItem,           // 11
-    BitXorTraitLangItem,        // 12
-    BitAndTraitLangItem,        // 13
-    BitOrTraitLangItem,         // 14
-    ShlTraitLangItem,           // 15
-    ShrTraitLangItem,           // 16
-    IndexTraitLangItem,         // 17
-
-    EqTraitLangItem,            // 18
-    OrdTraitLangItem,           // 19
-
-    StrEqFnLangItem,            // 20
-    UniqStrEqFnLangItem,        // 21
-    AnnihilateFnLangItem,       // 22
-    LogTypeFnLangItem,          // 23
-    FailFnLangItem,             // 24
-    FailBoundsCheckFnLangItem,  // 25
-    ExchangeMallocFnLangItem,   // 26
-    ExchangeFreeFnLangItem,     // 27
-    MallocFnLangItem,           // 28
-    FreeFnLangItem,             // 29
+    BitXorTraitLangItem,        // 11
+    BitAndTraitLangItem,        // 12
+    BitOrTraitLangItem,         // 13
+    ShlTraitLangItem,           // 14
+    ShrTraitLangItem,           // 15
+    IndexTraitLangItem,         // 16
+
+    EqTraitLangItem,            // 17
+    OrdTraitLangItem,           // 18
+
+    StrEqFnLangItem,            // 19
+    UniqStrEqFnLangItem,        // 20
+    AnnihilateFnLangItem,       // 21
+    LogTypeFnLangItem,          // 22
+    FailFnLangItem,             // 23
+    FailBoundsCheckFnLangItem,  // 24
+    ExchangeMallocFnLangItem,   // 25
+    ExchangeFreeFnLangItem,     // 26
+    MallocFnLangItem,           // 27
+    FreeFnLangItem,             // 28
 }
 
 struct LanguageItems {
-    items: [ Option<def_id> * 30 ]
+    items: [ Option<def_id> * 29 ]
 }
 
 impl LanguageItems {
     static pub fn new() -> LanguageItems {
         LanguageItems {
-            items: [ None, ..30 ]
+            items: [ None, ..29 ]
         }
     }
 
@@ -107,26 +106,25 @@ impl LanguageItems {
             8  => "div",
             9  => "modulo",
             10 => "neg",
-            11 => "not",
-            12 => "bitxor",
-            13 => "bitand",
-            14 => "bitor",
-            15 => "shl",
-            16 => "shr",
-            17 => "index",
-            18 => "eq",
-            19 => "ord",
-
-            20 => "str_eq",
-            21 => "uniq_str_eq",
-            22 => "annihilate",
-            23 => "log_type",
-            24 => "fail_",
-            25 => "fail_bounds_check",
-            26 => "exchange_malloc",
-            27 => "exchange_free",
-            28 => "malloc",
-            29 => "free",
+            11 => "bitxor",
+            12 => "bitand",
+            13 => "bitor",
+            14 => "shl",
+            15 => "shr",
+            16 => "index",
+            17 => "eq",
+            18 => "ord",
+
+            19 => "str_eq",
+            20 => "uniq_str_eq",
+            21 => "annihilate",
+            22 => "log_type",
+            23 => "fail_",
+            24 => "fail_bounds_check",
+            25 => "exchange_malloc",
+            26 => "exchange_free",
+            27 => "malloc",
+            28 => "free",
 
             _ => "???"
         }
@@ -169,9 +167,6 @@ impl LanguageItems {
     pub fn neg_trait(&const self) -> def_id {
         self.items[NegTraitLangItem as uint].get()
     }
-    pub fn not_trait(&const self) -> def_id {
-        self.items[NotTraitLangItem as uint].get()
-    }
     pub fn bitxor_trait(&const self) -> def_id {
         self.items[BitXorTraitLangItem as uint].get()
     }
@@ -249,7 +244,6 @@ fn LanguageItemCollector(crate: @crate,
     item_refs.insert(~"div", DivTraitLangItem as uint);
     item_refs.insert(~"modulo", ModuloTraitLangItem as uint);
     item_refs.insert(~"neg", NegTraitLangItem as uint);
-    item_refs.insert(~"not", NotTraitLangItem as uint);
     item_refs.insert(~"bitxor", BitXorTraitLangItem as uint);
     item_refs.insert(~"bitand", BitAndTraitLangItem as uint);
     item_refs.insert(~"bitor", BitOrTraitLangItem as uint);

branches/incoming/src/librustc/middle/resolve.rs

@@ -54,7 +54,7 @@ use syntax::ast::{ty_str, ty_u, ty_u16, ty_u32, ty_u64, ty_u8, ty_uint};
 use syntax::ast::{type_value_ns, ty_param_bound, unnamed_field};
 use syntax::ast::{variant, view_item, view_item_export, view_item_import};
 use syntax::ast::{view_item_use, view_path_glob, view_path_list};
-use syntax::ast::{view_path_simple, visibility, anonymous, named, not};
+use syntax::ast::{view_path_simple, visibility, anonymous, named};
 use syntax::ast_util::{def_id_of_def, dummy_sp, local_def};
 use syntax::ast_util::{path_to_ident, walk_pat, trait_method_to_ty_method};
 use syntax::ast_util::{Privacy, Public, Private, visibility_to_privacy};
@@ -5217,10 +5217,6 @@ impl Resolver {
                 self.add_fixed_trait_for_expr(expr.id,
                                               self.lang_items.neg_trait());
             }
-            expr_unary(not, _) => {
-                self.add_fixed_trait_for_expr(expr.id,
-                                              self.lang_items.not_trait());
-            }
             expr_index(*) => {
                 self.add_fixed_trait_for_expr(expr.id,
                                               self.lang_items.index_trait());

branches/incoming/src/libstd/net_url.rs

@@ -1077,12 +1077,16 @@ mod tests {
 
     #[test]
     fn test_decode_form_urlencoded() {
+        // FIXME #4449: Commented out because this causes an ICE, but only
+        // on FreeBSD
+        /*
         assert decode_form_urlencoded(~[]).len() == 0;
 
         let s = str::to_bytes("a=1&foo+bar=abc&foo+bar=12+%3D+34");
         let form = decode_form_urlencoded(s);
         assert form.len() == 2;
         assert form.get_ref(&~"a") == &~[~"1"];
         assert form.get_ref(&~"foo bar") == &~[~"abc", ~"12 = 34"];
+        */
     }
 }

branches/incoming/src/test/run-pass/operator-overloading.rs

@@ -34,12 +34,6 @@ impl Point : ops::Neg<Point> {
     }
 }
 
-impl Point : ops::Not<Point> {
-    pure fn not(&self) -> Point {
-        Point {x: !self.x, y: !self.y }
-    }
-}
-
 impl Point : ops::Index<bool,int> {
     pure fn index(&self, +x: bool) -> int {
         if x { self.x } else { self.y }
@@ -61,11 +55,6 @@ fn main() {
     assert -p == Point {x: -11, y: -22};
     assert p[true] == 11;
     assert p[false] == 22;
-
-    let q = !p;
-    assert q.x == !(p.x);
-    assert q.y == !(p.y);
-
     // Issue #1733
     fn~(_x: int){}(p[true]);
 }