From bb833ca0f0e878d381c3dc0c9afe958a810e4427 Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Thu, 14 Feb 2013 21:17:26 -0800 Subject: [PATCH] librustc: Stop parsing `impl Type : Trait` and fix several declarations that slipped through. r=tjc --- src/libcargo/cargo.rc | 2 +- src/libcore/at_vec.rs | 2 +- src/libcore/num/f32.rs | 2 +- src/libcore/num/f64.rs | 2 +- src/libcore/num/float.rs | 2 +- src/libcore/num/int-template/i16.rs | 2 +- src/libcore/num/int-template/i32.rs | 2 +- src/libcore/num/int-template/i64.rs | 2 +- src/libcore/num/int-template/i8.rs | 2 +- src/libcore/num/int-template/int.rs | 2 +- src/libcore/num/uint-template/u16.rs | 2 +- src/libcore/num/uint-template/u32.rs | 2 +- src/libcore/num/uint-template/u64.rs | 2 +- src/libcore/num/uint-template/u8.rs | 2 +- src/libcore/num/uint-template/uint.rs | 4 +- src/libcore/pipes.rs | 6 +- src/libcore/str.rs | 2 +- src/libcore/to_bytes.rs | 4 +- src/librustc/driver/driver.rs | 8 +- src/librustc/driver/session.rs | 24 +--- src/librustc/lib/llvm.rs | 41 +----- src/librustc/middle/borrowck/mod.rs | 2 +- src/librustc/middle/mem_categorization.rs | 6 +- src/librustc/middle/trans/base.rs | 6 +- src/librustc/middle/trans/common.rs | 10 +- src/librustc/middle/trans/datum.rs | 16 +-- src/librustc/middle/ty.rs | 30 ++--- src/librustc/middle/typeck/check/mod.rs | 4 +- src/librustc/middle/typeck/collect.rs | 2 +- src/librustc/middle/typeck/infer/glb.rs | 2 +- src/librustc/middle/typeck/infer/lattice.rs | 10 +- src/librustc/middle/typeck/infer/lub.rs | 2 +- src/librustc/middle/typeck/infer/sub.rs | 2 +- src/librustc/middle/typeck/infer/to_str.rs | 18 +-- src/librustc/middle/typeck/infer/unify.rs | 10 +- src/librustc/middle/typeck/rscope.rs | 8 +- src/librustc/rustc.rc | 8 +- src/librustdoc/config.rs | 2 +- src/librustdoc/markdown_pass.rs | 2 +- src/librustdoc/tystr_pass.rs | 2 +- src/libstd/flatpipes.rs | 38 +++--- src/libstd/json.rs | 8 +- src/libstd/prettyprint.rs | 2 +- src/libstd/serialize.rs | 124 +++++++++--------- src/libstd/workcache.rs | 4 +- src/libsyntax/ast.rs | 48 +++---- src/libsyntax/ast_map.rs | 2 +- src/libsyntax/ast_util.rs | 4 +- src/libsyntax/codemap.rs | 30 ++--- src/libsyntax/ext/pipes/ast_builder.rs | 4 +- src/libsyntax/ext/pipes/check.rs | 2 +- src/libsyntax/ext/pipes/parse_proto.rs | 2 +- src/libsyntax/ext/pipes/pipec.rs | 7 +- src/libsyntax/ext/pipes/proto.rs | 5 +- src/libsyntax/fold.rs | 2 +- src/libsyntax/parse/lexer.rs | 2 +- src/libsyntax/parse/obsolete.rs | 9 +- src/libsyntax/parse/parser.rs | 14 +- src/libsyntax/util/interner.rs | 2 +- src/test/auxiliary/cci_class_cast.rs | 2 +- .../crate-method-reexport-grrrrrrr2.rs | 4 +- src/test/auxiliary/issue-3012-1.rs | 2 +- src/test/auxiliary/issue2170lib.rs | 2 +- .../trait_inheritance_overloading_xc.rs | 10 +- src/test/compile-fail/issue-3953.rs | 2 +- src/test/compile-fail/issue-3969.rs | 2 +- .../compile-fail/missing-derivable-attr.rs | 2 +- src/test/run-pass/issue-2718.rs | 12 +- src/test/run-pass/issue-3563-3.rs | 9 +- src/test/run-pass/issue-3979.rs | 2 +- .../run-pass/pipe-presentation-examples.rs | 2 +- src/test/run-pass/static-impl.rs | 4 +- .../run-pass/static-methods-in-traits2.rs | 4 +- src/test/run-pass/trait-inheritance-num2.rs | 104 +++++++-------- src/test/run-pass/trait-inheritance-num3.rs | 2 +- src/test/run-pass/trait-inheritance-num5.rs | 4 +- .../trait-inheritance-overloading-simple.rs | 2 +- .../run-pass/trait-inheritance-overloading.rs | 2 +- src/test/run-pass/trait-inheritance-subst.rs | 2 +- src/test/run-pass/trait-inheritance-subst2.rs | 2 +- src/test/run-pass/trait-inheritance2.rs | 2 +- .../trait-static-method-overwriting.rs | 4 +- 82 files changed, 327 insertions(+), 424 deletions(-) diff --git a/src/libcargo/cargo.rc b/src/libcargo/cargo.rc index eb5f871d053..dceeb96800f 100644 --- a/src/libcargo/cargo.rc +++ b/src/libcargo/cargo.rc @@ -71,7 +71,7 @@ pub struct Package { versions: ~[(~str, ~str)] } -pub impl Package : cmp::Ord { +pub impl cmp::Ord for Package { pure fn lt(&self, other: &Package) -> bool { if (*self).name.lt(&(*other).name) { return true; } if (*other).name.lt(&(*self).name) { return false; } diff --git a/src/libcore/at_vec.rs b/src/libcore/at_vec.rs index 71af60314da..565fe11d3f4 100644 --- a/src/libcore/at_vec.rs +++ b/src/libcore/at_vec.rs @@ -173,7 +173,7 @@ pub mod traits { use kinds::Copy; use ops::Add; - pub impl @[T] : Add<&[const T],@[T]> { + pub impl Add<&[const T],@[T]> for @[T] { #[inline(always)] pure fn add(&self, rhs: & &self/[const T]) -> @[T] { append(*self, (*rhs)) diff --git a/src/libcore/num/f32.rs b/src/libcore/num/f32.rs index 8350ba42591..59c4ce6b9dc 100644 --- a/src/libcore/num/f32.rs +++ b/src/libcore/num/f32.rs @@ -282,7 +282,7 @@ impl num::One for f32 { static pure fn one() -> f32 { 1.0 } } -pub impl f32: NumCast { +pub impl NumCast for f32 { /** * Cast `n` to an `f32` */ diff --git a/src/libcore/num/f64.rs b/src/libcore/num/f64.rs index 474067a1860..b24c76a5e0a 100644 --- a/src/libcore/num/f64.rs +++ b/src/libcore/num/f64.rs @@ -297,7 +297,7 @@ impl cmp::Ord for f64 { pure fn gt(&self, other: &f64) -> bool { (*self) > (*other) } } -pub impl f64: NumCast { +pub impl NumCast for f64 { /** * Cast `n` to an `f64` */ diff --git a/src/libcore/num/float.rs b/src/libcore/num/float.rs index 0f0b721e462..51b115e84c3 100644 --- a/src/libcore/num/float.rs +++ b/src/libcore/num/float.rs @@ -415,7 +415,7 @@ impl num::One for float { static pure fn one() -> float { 1.0 } } -pub impl float: NumCast { +pub impl NumCast for float { /** * Cast `n` to a `float` */ diff --git a/src/libcore/num/int-template/i16.rs b/src/libcore/num/int-template/i16.rs index 76725e3895b..1352959306a 100644 --- a/src/libcore/num/int-template/i16.rs +++ b/src/libcore/num/int-template/i16.rs @@ -17,7 +17,7 @@ mod inst { pub const bits: uint = ::u16::bits; } -pub impl i16: NumCast { +pub impl NumCast for i16 { /** * Cast `n` to a `i16` */ diff --git a/src/libcore/num/int-template/i32.rs b/src/libcore/num/int-template/i32.rs index 1c2d60a80ee..e8dd603d507 100644 --- a/src/libcore/num/int-template/i32.rs +++ b/src/libcore/num/int-template/i32.rs @@ -17,7 +17,7 @@ mod inst { pub const bits: uint = ::u32::bits; } -pub impl i32: NumCast { +pub impl NumCast for i32 { /** * Cast `n` to a `i32` */ diff --git a/src/libcore/num/int-template/i64.rs b/src/libcore/num/int-template/i64.rs index d7413920a64..6f1371f8ee2 100644 --- a/src/libcore/num/int-template/i64.rs +++ b/src/libcore/num/int-template/i64.rs @@ -17,7 +17,7 @@ mod inst { pub const bits: uint = ::u64::bits; } -pub impl i64: NumCast { +pub impl NumCast for i64 { /** * Cast `n` to a `i64` */ diff --git a/src/libcore/num/int-template/i8.rs b/src/libcore/num/int-template/i8.rs index f2577020128..46c734b9548 100644 --- a/src/libcore/num/int-template/i8.rs +++ b/src/libcore/num/int-template/i8.rs @@ -17,7 +17,7 @@ mod inst { pub const bits: uint = ::u8::bits; } -pub impl i8: NumCast { +pub impl NumCast for i8 { /** * Cast `n` to a `i8` */ diff --git a/src/libcore/num/int-template/int.rs b/src/libcore/num/int-template/int.rs index 4ba1570e135..83ef421b705 100644 --- a/src/libcore/num/int-template/int.rs +++ b/src/libcore/num/int-template/int.rs @@ -58,7 +58,7 @@ mod inst { } } -pub impl int: NumCast { +pub impl NumCast for int { /** * Cast `n` to a `int` */ diff --git a/src/libcore/num/uint-template/u16.rs b/src/libcore/num/uint-template/u16.rs index 57e1f5283f6..315ff84cc23 100644 --- a/src/libcore/num/uint-template/u16.rs +++ b/src/libcore/num/uint-template/u16.rs @@ -19,7 +19,7 @@ mod inst { pub const bits: uint = 16; } -pub impl u16: NumCast { +pub impl NumCast for u16 { /** * Cast `n` to a `u16` */ diff --git a/src/libcore/num/uint-template/u32.rs b/src/libcore/num/uint-template/u32.rs index 7099d15c40b..834feff292c 100644 --- a/src/libcore/num/uint-template/u32.rs +++ b/src/libcore/num/uint-template/u32.rs @@ -19,7 +19,7 @@ mod inst { pub const bits: uint = 32; } -pub impl u32: NumCast { +pub impl NumCast for u32 { /** * Cast `n` to a `u32` */ diff --git a/src/libcore/num/uint-template/u64.rs b/src/libcore/num/uint-template/u64.rs index f4d1482de90..b661b3b20b1 100644 --- a/src/libcore/num/uint-template/u64.rs +++ b/src/libcore/num/uint-template/u64.rs @@ -19,7 +19,7 @@ mod inst { pub const bits: uint = 64; } -pub impl u64: num::NumCast { +pub impl NumCast for u64 { /** * Cast `n` to a `u64` */ diff --git a/src/libcore/num/uint-template/u8.rs b/src/libcore/num/uint-template/u8.rs index e2f8e00db81..c2be9e252d9 100644 --- a/src/libcore/num/uint-template/u8.rs +++ b/src/libcore/num/uint-template/u8.rs @@ -26,7 +26,7 @@ mod inst { pub pure fn is_ascii(x: T) -> bool { return 0 as T == x & 128 as T; } } -pub impl u8: NumCast { +pub impl NumCast for u8 { /** * Cast `n` to a `u8` */ diff --git a/src/libcore/num/uint-template/uint.rs b/src/libcore/num/uint-template/uint.rs index cfb445cbdc8..475ae243915 100644 --- a/src/libcore/num/uint-template/uint.rs +++ b/src/libcore/num/uint-template/uint.rs @@ -110,7 +110,7 @@ pub mod inst { return true; } - pub impl uint: iter::Times { + pub impl iter::Times for uint { #[inline(always)] /** * A convenience form for basic iteration. Given a uint `x`, @@ -209,7 +209,7 @@ pub mod inst { } } -pub impl uint: NumCast { +pub impl NumCast for uint { /** * Cast `n` to a `uint` */ diff --git a/src/libcore/pipes.rs b/src/libcore/pipes.rs index b9e07135f2c..f0108fe85b7 100644 --- a/src/libcore/pipes.rs +++ b/src/libcore/pipes.rs @@ -1211,11 +1211,11 @@ pub trait Select2 { fn select() -> Either; } -impl, Right: Selectable GenericPort> - (Left, Right): Select2 { - + Select2 for (Left, Right) { fn select() -> Either { match self { (ref lp, ref rp) => match select2i(lp, rp) { diff --git a/src/libcore/str.rs b/src/libcore/str.rs index a95d4236ce9..3c15a89081d 100644 --- a/src/libcore/str.rs +++ b/src/libcore/str.rs @@ -2328,7 +2328,7 @@ pub trait OwnedStr { fn push_char(&mut self, c: char); } -pub impl ~str : OwnedStr { +pub impl OwnedStr for ~str { fn push_str(&mut self, v: &str) { push_str(self, v); } diff --git a/src/libcore/to_bytes.rs b/src/libcore/to_bytes.rs index 58ecf2560ac..10efa9196a7 100644 --- a/src/libcore/to_bytes.rs +++ b/src/libcore/to_bytes.rs @@ -170,7 +170,7 @@ impl IterBytes for char { pub mod x32 { use to_bytes::{Cb, IterBytes}; - pub impl uint: IterBytes { + pub impl IterBytes for uint { #[inline(always)] pure fn iter_bytes(&self, lsb0: bool, f: Cb) { (*self as u32).iter_bytes(lsb0, f) @@ -182,7 +182,7 @@ pub mod x32 { pub mod x64 { use to_bytes::{Cb, IterBytes}; - pub impl uint: IterBytes { + pub impl IterBytes for uint { #[inline(always)] pure fn iter_bytes(&self, lsb0: bool, f: Cb) { (*self as u64).iter_bytes(lsb0, f) diff --git a/src/librustc/driver/driver.rs b/src/librustc/driver/driver.rs index 08ba3515fd2..f1712d05562 100644 --- a/src/librustc/driver/driver.rs +++ b/src/librustc/driver/driver.rs @@ -175,6 +175,7 @@ pub fn time(do_it: bool, what: ~str, thunk: fn() -> T) -> T { rv } +#[deriving_eq] pub enum compile_upto { cu_parse, cu_expand, @@ -183,13 +184,6 @@ pub enum compile_upto { cu_everything, } -pub impl compile_upto : cmp::Eq { - pure fn eq(&self, other: &compile_upto) -> bool { - ((*self) as uint) == ((*other) as uint) - } - pure fn ne(&self, other: &compile_upto) -> bool { !(*self).eq(other) } -} - pub fn compile_upto(sess: Session, cfg: ast::crate_cfg, input: input, upto: compile_upto, outputs: Option) diff --git a/src/librustc/driver/session.rs b/src/librustc/driver/session.rs index cb55051c57f..1a299f22ec0 100644 --- a/src/librustc/driver/session.rs +++ b/src/librustc/driver/session.rs @@ -29,24 +29,12 @@ use syntax::parse::parse_sess; use syntax::{ast, codemap}; use syntax; +#[deriving_eq] pub enum os { os_win32, os_macos, os_linux, os_android, os_freebsd, } -pub impl os : cmp::Eq { - pure fn eq(&self, other: &os) -> bool { - ((*self) as uint) == ((*other) as uint) - } - pure fn ne(&self, other: &os) -> bool { !(*self).eq(other) } -} - +#[deriving_eq] pub enum arch { arch_x86, arch_x86_64, arch_arm, } -pub impl arch : cmp::Eq { - pure fn eq(&self, other: &arch) -> bool { - ((*self) as uint) == ((*other) as uint) - } - pure fn ne(&self, other: &arch) -> bool { !(*self).eq(other) } -} - pub enum crate_type { bin_crate, lib_crate, unknown_crate, } pub type config = @@ -117,6 +105,7 @@ pub fn debugging_opts_map() -> ~[(~str, ~str, uint)] { ] } +#[deriving_eq] pub enum OptLevel { No, // -O0 Less, // -O1 @@ -124,13 +113,6 @@ pub enum OptLevel { Aggressive // -O3 } -pub impl OptLevel : cmp::Eq { - pure fn eq(&self, other: &OptLevel) -> bool { - ((*self) as uint) == ((*other) as uint) - } - pure fn ne(&self, other: &OptLevel) -> bool { !(*self).eq(other) } -} - pub type options = // The crate config requested for the session, which may be combined // with additional crate configurations during the compile process diff --git a/src/librustc/lib/llvm.rs b/src/librustc/lib/llvm.rs index e18a7e7d1d8..c58ab494ed3 100644 --- a/src/librustc/lib/llvm.rs +++ b/src/librustc/lib/llvm.rs @@ -132,6 +132,7 @@ pub enum RealPredicate { // enum for the LLVM TypeKind type - must stay in sync with the def of // LLVMTypeKind in llvm/include/llvm-c/Core.h +#[deriving_eq] pub enum TypeKind { Void = 0, Half = 1, @@ -151,46 +152,6 @@ pub enum TypeKind { X86_MMX = 15 } -pub impl TypeKind : cmp::Eq { - pure fn eq(&self, other: &TypeKind) -> bool { - match ((*self), (*other)) { - (Void, Void) => true, - (Half, Half) => true, - (Float, Float) => true, - (Double, Double) => true, - (X86_FP80, X86_FP80) => true, - (FP128, FP128) => true, - (PPC_FP128, PPC_FP128) => true, - (Label, Label) => true, - (Integer, Integer) => true, - (Function, Function) => true, - (Struct, Struct) => true, - (Array, Array) => true, - (Pointer, Pointer) => true, - (Vector, Vector) => true, - (Metadata, Metadata) => true, - (X86_MMX, X86_MMX) => true, - (Void, _) => false, - (Half, _) => false, - (Float, _) => false, - (Double, _) => false, - (X86_FP80, _) => false, - (FP128, _) => false, - (PPC_FP128, _) => false, - (Label, _) => false, - (Integer, _) => false, - (Function, _) => false, - (Struct, _) => false, - (Array, _) => false, - (Pointer, _) => false, - (Vector, _) => false, - (Metadata, _) => false, - (X86_MMX, _) => false, - } - } - pure fn ne(&self, other: &TypeKind) -> bool { !(*self).eq(other) } -} - pub enum AtomicBinOp { Xchg = 0, Add = 1, diff --git a/src/librustc/middle/borrowck/mod.rs b/src/librustc/middle/borrowck/mod.rs index 40f5a001632..a420faf1f1d 100644 --- a/src/librustc/middle/borrowck/mod.rs +++ b/src/librustc/middle/borrowck/mod.rs @@ -449,7 +449,7 @@ impl LoanKind { /// Creates and returns a new root_map -pub impl root_map_key : to_bytes::IterBytes { +pub impl to_bytes::IterBytes for root_map_key { pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { to_bytes::iter_bytes_2(&self.id, &self.derefs, lsb0, f); } diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index c4612e76024..da2c8965ba1 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -281,12 +281,12 @@ pub trait ast_node { fn span() -> span; } -pub impl @ast::expr: ast_node { +pub impl ast_node for @ast::expr { fn id() -> ast::node_id { self.id } fn span() -> span { self.span } } -pub impl @ast::pat: ast_node { +pub impl ast_node for @ast::pat { fn id() -> ast::node_id { self.id } fn span() -> span { self.span } } @@ -295,7 +295,7 @@ pub trait get_type_for_node { fn ty(node: N) -> ty::t; } -pub impl ty::ctxt: get_type_for_node { +pub impl get_type_for_node for ty::ctxt { fn ty(node: N) -> ty::t { ty::node_id_to_type(self, node.id()) } diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs index f38e56278c5..71103650340 100644 --- a/src/librustc/middle/trans/base.rs +++ b/src/librustc/middle/trans/base.rs @@ -108,7 +108,7 @@ pub trait get_insn_ctxt { fn insn_ctxt(s: &str) -> icx_popper; } -pub impl @crate_ctxt: get_insn_ctxt { +pub impl get_insn_ctxt for @crate_ctxt { fn insn_ctxt(s: &str) -> icx_popper { debug!("new insn_ctxt: %s", s); if self.sess.count_llvm_insns() { @@ -118,13 +118,13 @@ pub impl @crate_ctxt: get_insn_ctxt { } } -pub impl block: get_insn_ctxt { +pub impl get_insn_ctxt for block { fn insn_ctxt(s: &str) -> icx_popper { self.ccx().insn_ctxt(s) } } -pub impl fn_ctxt: get_insn_ctxt { +pub impl get_insn_ctxt for fn_ctxt { fn insn_ctxt(s: &str) -> icx_popper { self.ccx.insn_ctxt(s) } diff --git a/src/librustc/middle/trans/common.rs b/src/librustc/middle/trans/common.rs index 606a318523b..13902be776b 100644 --- a/src/librustc/middle/trans/common.rs +++ b/src/librustc/middle/trans/common.rs @@ -532,13 +532,13 @@ pub trait get_node_info { fn info() -> Option; } -pub impl @ast::expr: get_node_info { +pub impl get_node_info for @ast::expr { fn info() -> Option { Some({id: self.id, span: self.span}) } } -pub impl ast::blk: get_node_info { +pub impl get_node_info for ast::blk { fn info() -> Option { Some({id: self.node.id, span: self.span}) } @@ -547,7 +547,7 @@ pub impl ast::blk: get_node_info { // XXX: Work around a trait parsing bug. remove after snapshot pub type optional_boxed_ast_expr = Option<@ast::expr>; -pub impl optional_boxed_ast_expr: get_node_info { +pub impl get_node_info for optional_boxed_ast_expr { fn info() -> Option { self.chain_ref(|s| s.info()) } @@ -1280,7 +1280,7 @@ pub struct mono_id_ { pub type mono_id = @mono_id_; -pub impl mono_param_id : to_bytes::IterBytes { +pub impl to_bytes::IterBytes for mono_param_id { pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { match /*bad*/copy *self { mono_precise(t, mids) => @@ -1294,7 +1294,7 @@ pub impl mono_param_id : to_bytes::IterBytes { } } -pub impl mono_id_ : to_bytes::IterBytes { +pub impl to_bytes::IterBytes for mono_id_ { pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { to_bytes::iter_bytes_2(&self.def, &self.params, lsb0, f); } diff --git a/src/librustc/middle/trans/datum.rs b/src/librustc/middle/trans/datum.rs index d301a31357b..49779b9bbcc 100644 --- a/src/librustc/middle/trans/datum.rs +++ b/src/librustc/middle/trans/datum.rs @@ -104,6 +104,7 @@ use core::uint; use core::vec; use syntax::parse::token::special_idents; +#[deriving_eq] pub enum CopyAction { INIT, DROP_EXISTING @@ -150,14 +151,14 @@ pub impl DatumMode { } } -pub impl DatumMode: cmp::Eq { +pub impl cmp::Eq for DatumMode { pure fn eq(&self, other: &DatumMode) -> bool { (*self) as uint == (*other as uint) } pure fn ne(&self, other: &DatumMode) -> bool { !(*self).eq(other) } } -pub impl DatumMode: to_bytes::IterBytes { +pub impl to_bytes::IterBytes for DatumMode { pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { (*self as uint).iter_bytes(lsb0, f) } @@ -846,14 +847,3 @@ pub impl DatumBlock { } } -pub impl CopyAction : cmp::Eq { - pure fn eq(&self, other: &CopyAction) -> bool { - match ((*self), (*other)) { - (INIT, INIT) => true, - (DROP_EXISTING, DROP_EXISTING) => true, - (INIT, _) => false, - (DROP_EXISTING, _) => false, - } - } - pure fn ne(&self, other: &CopyAction) -> bool { !(*self).eq(other) } -} diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index a30e0df8452..c15010d7b7b 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -657,46 +657,46 @@ pub trait Vid { pure fn to_uint() -> uint; } -pub impl TyVid: Vid { +pub impl Vid for TyVid { pure fn to_uint() -> uint { *self } } -pub impl TyVid: ToStr { +pub impl ToStr for TyVid { pure fn to_str(&self) -> ~str { fmt!("", self.to_uint()) } } -pub impl IntVid: Vid { +pub impl Vid for IntVid { pure fn to_uint() -> uint { *self } } -pub impl IntVid: ToStr { +pub impl ToStr for IntVid { pure fn to_str(&self) -> ~str { fmt!("", self.to_uint()) } } -pub impl FloatVid: Vid { +pub impl Vid for FloatVid { pure fn to_uint() -> uint { *self } } -pub impl FloatVid: ToStr { +pub impl ToStr for FloatVid { pure fn to_str(&self) -> ~str { fmt!("", self.to_uint()) } } -pub impl RegionVid: Vid { +pub impl Vid for RegionVid { pure fn to_uint() -> uint { *self } } -pub impl RegionVid: ToStr { +pub impl ToStr for RegionVid { pure fn to_str(&self) -> ~str { fmt!("%?", self) } } -pub impl FnSig : ToStr { +pub impl ToStr for FnSig { pure fn to_str(&self) -> ~str { // grr, without tcx not much we can do. return ~"(...)"; } } -pub impl InferTy: ToStr { +pub impl ToStr for InferTy { pure fn to_str(&self) -> ~str { match *self { TyVar(ref v) => v.to_str(), @@ -706,7 +706,7 @@ pub impl InferTy: ToStr { } } -pub impl IntVarValue : ToStr { +pub impl ToStr for IntVarValue { pure fn to_str(&self) -> ~str { match *self { IntType(ref v) => v.to_str(), @@ -715,25 +715,25 @@ pub impl IntVarValue : ToStr { } } -pub impl TyVid : to_bytes::IterBytes { +pub impl to_bytes::IterBytes for TyVid { pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { self.to_uint().iter_bytes(lsb0, f) } } -pub impl IntVid : to_bytes::IterBytes { +pub impl to_bytes::IterBytes for IntVid { pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { self.to_uint().iter_bytes(lsb0, f) } } -pub impl FloatVid : to_bytes::IterBytes { +pub impl to_bytes::IterBytes for FloatVid { pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { self.to_uint().iter_bytes(lsb0, f) } } -pub impl RegionVid : to_bytes::IterBytes { +pub impl to_bytes::IterBytes for RegionVid { pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { self.to_uint().iter_bytes(lsb0, f) } diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs index 706f6d82c87..1ad3bd9cae6 100644 --- a/src/librustc/middle/typeck/check/mod.rs +++ b/src/librustc/middle/typeck/check/mod.rs @@ -620,7 +620,7 @@ pub fn check_item(ccx: @mut CrateCtxt, it: @ast::item) { } } -pub impl FnCtxt: AstConv { +pub impl AstConv for FnCtxt { fn tcx(@mut self) -> ty::ctxt { self.ccx.tcx } fn ccx(@mut self) -> @mut CrateCtxt { self.ccx } @@ -654,7 +654,7 @@ pub impl FnCtxt { } } -pub impl @mut FnCtxt: region_scope { +pub impl region_scope for @mut FnCtxt { pure fn anon_region(span: span) -> Result { // XXX: Unsafe to work around purity unsafe { diff --git a/src/librustc/middle/typeck/collect.rs b/src/librustc/middle/typeck/collect.rs index 17ed0c0a93f..972d1b60945 100644 --- a/src/librustc/middle/typeck/collect.rs +++ b/src/librustc/middle/typeck/collect.rs @@ -121,7 +121,7 @@ pub impl @mut CrateCtxt { } } -pub impl CrateCtxt: AstConv { +pub impl AstConv for CrateCtxt { fn tcx(@mut self) -> ty::ctxt { self.tcx } fn ccx(@mut self) -> @mut CrateCtxt { self } diff --git a/src/librustc/middle/typeck/infer/glb.rs b/src/librustc/middle/typeck/infer/glb.rs index e51fd14f665..464a149a488 100644 --- a/src/librustc/middle/typeck/infer/glb.rs +++ b/src/librustc/middle/typeck/infer/glb.rs @@ -27,7 +27,7 @@ use std::list; pub enum Glb = CombineFields; // "greatest lower bound" (common subtype) -pub impl Glb: Combine { +pub impl Combine for Glb { fn infcx() -> @mut InferCtxt { self.infcx } fn tag() -> ~str { ~"glb" } fn a_is_expected() -> bool { self.a_is_expected } diff --git a/src/librustc/middle/typeck/infer/lattice.rs b/src/librustc/middle/typeck/infer/lattice.rs index 709864c0d13..df4bc46ba63 100644 --- a/src/librustc/middle/typeck/infer/lattice.rs +++ b/src/librustc/middle/typeck/infer/lattice.rs @@ -57,7 +57,7 @@ pub trait LatticeValue { pub type LatticeOp = &fn(cf: &CombineFields, a: &T, b: &T) -> cres; -pub impl ty::t: LatticeValue { +pub impl LatticeValue for ty::t { static fn sub(cf: &CombineFields, a: &ty::t, b: &ty::t) -> ures { Sub(*cf).tys(*a, *b).to_ures() } @@ -301,7 +301,7 @@ pub trait TyLatticeDir { fn ty_bot(t: ty::t) -> cres; } -pub impl Lub: LatticeDir { +pub impl LatticeDir for Lub { fn combine_fields() -> CombineFields { *self } fn bnd(b: &Bounds) -> Option { b.ub } fn with_bnd(b: &Bounds, +t: T) -> Bounds { @@ -309,13 +309,13 @@ pub impl Lub: LatticeDir { } } -pub impl Lub: TyLatticeDir { +pub impl TyLatticeDir for Lub { fn ty_bot(t: ty::t) -> cres { Ok(t) } } -pub impl Glb: LatticeDir { +pub impl LatticeDir for Glb { fn combine_fields() -> CombineFields { *self } fn bnd(b: &Bounds) -> Option { b.lb } fn with_bnd(b: &Bounds, +t: T) -> Bounds { @@ -323,7 +323,7 @@ pub impl Glb: LatticeDir { } } -pub impl Glb: TyLatticeDir { +pub impl TyLatticeDir for Glb { fn ty_bot(_t: ty::t) -> cres { Ok(ty::mk_bot(self.infcx.tcx)) } diff --git a/src/librustc/middle/typeck/infer/lub.rs b/src/librustc/middle/typeck/infer/lub.rs index fd4b2fdf32b..60f6cd40e04 100644 --- a/src/librustc/middle/typeck/infer/lub.rs +++ b/src/librustc/middle/typeck/infer/lub.rs @@ -36,7 +36,7 @@ pub impl Lub { fn ty_bot(b: ty::t) -> cres { self.bot_ty(b) } // commutative } -pub impl Lub: Combine { +pub impl Combine for Lub { fn infcx() -> @mut InferCtxt { self.infcx } fn tag() -> ~str { ~"lub" } fn a_is_expected() -> bool { self.a_is_expected } diff --git a/src/librustc/middle/typeck/infer/sub.rs b/src/librustc/middle/typeck/infer/sub.rs index 33a3220f68a..8b37b668ff7 100644 --- a/src/librustc/middle/typeck/infer/sub.rs +++ b/src/librustc/middle/typeck/infer/sub.rs @@ -32,7 +32,7 @@ pub fn macros() { pub enum Sub = CombineFields; // "subtype", "subregion" etc -pub impl Sub: Combine { +pub impl Combine for Sub { fn infcx() -> @mut InferCtxt { self.infcx } fn tag() -> ~str { ~"sub" } fn a_is_expected() -> bool { self.a_is_expected } diff --git a/src/librustc/middle/typeck/infer/to_str.rs b/src/librustc/middle/typeck/infer/to_str.rs index bade7639e4b..89de219f7f6 100644 --- a/src/librustc/middle/typeck/infer/to_str.rs +++ b/src/librustc/middle/typeck/infer/to_str.rs @@ -28,13 +28,13 @@ pub trait InferStr { fn inf_str(&self, cx: &InferCtxt) -> ~str; } -pub impl ty::t : InferStr { +pub impl InferStr for ty::t { fn inf_str(&self, cx: &InferCtxt) -> ~str { ty_to_str(cx.tcx, *self) } } -pub impl FnSig : InferStr { +pub impl InferStr for FnSig { fn inf_str(&self, cx: &InferCtxt) -> ~str { fmt!("(%s) -> %s", str::connect(self.inputs.map(|a| a.ty.inf_str(cx)), ", "), @@ -42,19 +42,19 @@ pub impl FnSig : InferStr { } } -pub impl ty::mt : InferStr { +pub impl InferStr for ty::mt { fn inf_str(&self, cx: &InferCtxt) -> ~str { mt_to_str(cx.tcx, *self) } } -pub impl ty::Region : InferStr { +pub impl InferStr for ty::Region { fn inf_str(&self, _cx: &InferCtxt) -> ~str { fmt!("%?", *self) } } -pub impl Bound : InferStr { +pub impl InferStr for Bound { fn inf_str(&self, cx: &InferCtxt) -> ~str { match *self { Some(ref v) => v.inf_str(cx), @@ -63,7 +63,7 @@ pub impl Bound : InferStr { } } -pub impl Bounds : InferStr { +pub impl InferStr for Bounds { fn inf_str(&self, cx: &InferCtxt) -> ~str { fmt!("{%s <: %s}", self.lb.inf_str(cx), @@ -71,7 +71,7 @@ pub impl Bounds : InferStr { } } -pub impl VarValue : InferStr { +pub impl InferStr for VarValue { fn inf_str(&self, cx: &InferCtxt) -> ~str { match *self { Redirect(ref vid) => fmt!("Redirect(%s)", vid.to_str()), @@ -81,13 +81,13 @@ pub impl VarValue : InferStr { } } -pub impl IntVarValue : InferStr { +pub impl InferStr for IntVarValue { fn inf_str(&self, _cx: &InferCtxt) -> ~str { self.to_str() } } -pub impl ast::float_ty : InferStr { +pub impl InferStr for ast::float_ty { fn inf_str(&self, _cx: &InferCtxt) -> ~str { self.to_str() } diff --git a/src/librustc/middle/typeck/infer/unify.rs b/src/librustc/middle/typeck/infer/unify.rs index 69e4f373f97..b2aac9192f3 100644 --- a/src/librustc/middle/typeck/infer/unify.rs +++ b/src/librustc/middle/typeck/infer/unify.rs @@ -237,35 +237,35 @@ pub impl InferCtxt { // ______________________________________________________________________ -pub impl ty::TyVid : UnifyVid> { +pub impl UnifyVid> for ty::TyVid { static fn appropriate_vals_and_bindings(infcx: &v/mut InferCtxt) -> &v/mut ValsAndBindings> { return &mut infcx.ty_var_bindings; } } -pub impl ty::IntVid : UnifyVid> { +pub impl UnifyVid> for ty::IntVid { static fn appropriate_vals_and_bindings(infcx: &v/mut InferCtxt) -> &v/mut ValsAndBindings> { return &mut infcx.int_var_bindings; } } -pub impl IntVarValue : SimplyUnifiable { +pub impl SimplyUnifiable for IntVarValue { static fn to_type_err(err: expected_found) -> ty::type_err { return ty::terr_int_mismatch(err); } } -pub impl ty::FloatVid : UnifyVid> { +pub impl UnifyVid> for ty::FloatVid { static fn appropriate_vals_and_bindings(infcx: &v/mut InferCtxt) -> &v/mut ValsAndBindings> { return &mut infcx.float_var_bindings; } } -pub impl ast::float_ty : SimplyUnifiable { +pub impl SimplyUnifiable for ast::float_ty { static fn to_type_err(err: expected_found) -> ty::type_err { return ty::terr_float_mismatch(err); diff --git a/src/librustc/middle/typeck/rscope.rs b/src/librustc/middle/typeck/rscope.rs index fab86ef69fe..4739a183cb8 100644 --- a/src/librustc/middle/typeck/rscope.rs +++ b/src/librustc/middle/typeck/rscope.rs @@ -26,7 +26,7 @@ pub trait region_scope { } pub enum empty_rscope { empty_rscope } -pub impl empty_rscope: region_scope { +pub impl region_scope for empty_rscope { pure fn anon_region(_span: span) -> Result { result::Ok(ty::re_static) } @@ -40,7 +40,7 @@ pub impl empty_rscope: region_scope { } pub enum type_rscope = Option; -pub impl type_rscope: region_scope { +pub impl region_scope for type_rscope { pure fn anon_region(_span: span) -> Result { match *self { Some(_) => result::Ok(ty::re_bound(ty::br_self)), @@ -73,7 +73,7 @@ pub fn in_anon_rscope(self: RS, r: ty::Region) -> @anon_rscope { @anon_rscope({anon: r, base: self as region_scope}) } -pub impl @anon_rscope: region_scope { +pub impl region_scope for @anon_rscope { pure fn anon_region(_span: span) -> Result { result::Ok(self.anon) } @@ -96,7 +96,7 @@ pub fn in_binding_rscope(self: RS) let base = self as region_scope; @mut binding_rscope { base: base, anon_bindings: 0 } } -pub impl @mut binding_rscope: region_scope { +pub impl region_scope for @mut binding_rscope { pure fn anon_region(_span: span) -> Result { // XXX: Unsafe to work around purity unsafe { diff --git a/src/librustc/rustc.rc b/src/librustc/rustc.rc index 52a8e5488d8..b726ecacc45 100644 --- a/src/librustc/rustc.rc +++ b/src/librustc/rustc.rc @@ -296,18 +296,12 @@ pub fn run_compiler(args: &~[~str], demitter: diagnostic::Emitter) { compile_input(sess, cfg, input, &odir, &ofile); } +#[deriving_eq] pub enum monitor_msg { fatal, done, } -pub impl monitor_msg : cmp::Eq { - pure fn eq(&self, other: &monitor_msg) -> bool { - ((*self) as uint) == ((*other) as uint) - } - pure fn ne(&self, other: &monitor_msg) -> bool { !(*self).eq(other) } -} - /* This is a sanity check that any failure of the compiler is performed through the diagnostic module and reported properly - we shouldn't be calling diff --git a/src/librustdoc/config.rs b/src/librustdoc/config.rs index ceea3d0e798..e904015e419 100644 --- a/src/librustdoc/config.rs +++ b/src/librustdoc/config.rs @@ -59,7 +59,7 @@ pub struct Config { pandoc_cmd: Option<~str> } -pub impl Config: Clone { +pub impl Clone for Config { fn clone(&self) -> Config { copy *self } } diff --git a/src/librustdoc/markdown_pass.rs b/src/librustdoc/markdown_pass.rs index 6a56a1c66e7..ff9faabaec2 100644 --- a/src/librustdoc/markdown_pass.rs +++ b/src/librustdoc/markdown_pass.rs @@ -761,7 +761,7 @@ fn should_write_impl_header() { #[test] fn should_write_impl_header_with_trait() { - let markdown = test::render(~"impl int: j { fn a() { } }"); + let markdown = test::render(~"impl j for int { fn a() { } }"); assert str::contains(markdown, ~"## Implementation of `j` for `int`"); } diff --git a/src/librustdoc/tystr_pass.rs b/src/librustdoc/tystr_pass.rs index c14eb32022f..42961e7bca6 100644 --- a/src/librustdoc/tystr_pass.rs +++ b/src/librustdoc/tystr_pass.rs @@ -297,7 +297,7 @@ fn fold_impl( #[test] fn should_add_impl_trait_types() { - let doc = test::mk_doc(~"impl int: j { fn a() { } }"); + let doc = test::mk_doc(~"impl j for int { fn a() { } }"); assert doc.cratemod().impls()[0].trait_types[0] == ~"j"; } diff --git a/src/libstd/flatpipes.rs b/src/libstd/flatpipes.rs index d33ed4fd7cb..cff30587607 100644 --- a/src/libstd/flatpipes.rs +++ b/src/libstd/flatpipes.rs @@ -258,7 +258,7 @@ pub trait ByteChan { const CONTINUE: [u8 * 4] = [0xAA, 0xBB, 0xCC, 0xDD]; -pub impl,P:BytePort> FlatPort: GenericPort { +pub impl,P:BytePort> GenericPort for FlatPort { fn recv() -> T { match self.try_recv() { Some(val) => val, @@ -358,7 +358,7 @@ pub mod flatteners { bogus: () } - pub impl PodUnflattener: Unflattener { + pub impl Unflattener for PodUnflattener { fn unflatten(&self, buf: ~[u8]) -> T { assert size_of::() != 0; assert size_of::() == buf.len(); @@ -368,7 +368,7 @@ pub mod flatteners { } } - pub impl PodFlattener: Flattener { + pub impl Flattener for PodFlattener { fn flatten(&self, val: T) -> ~[u8] { assert size_of::() != 0; let val: *T = ptr::to_unsafe_ptr(&val); @@ -406,36 +406,32 @@ pub mod flatteners { serialize_value: SerializeValue } - pub impl> - DeserializingUnflattener: Unflattener { + pub impl> Unflattener + for DeserializingUnflattener { fn unflatten(&self, buf: ~[u8]) -> T { (self.deserialize_buffer)(buf) } } - pub impl> - SerializingFlattener: Flattener { + pub impl> Flattener + for SerializingFlattener { fn flatten(&self, val: T) -> ~[u8] { (self.serialize_value)(&val) } } - pub impl> - DeserializingUnflattener { - - static fn new(deserialize_buffer: DeserializeBuffer - ) -> DeserializingUnflattener { + pub impl> DeserializingUnflattener { + static fn new(deserialize_buffer: DeserializeBuffer) + -> DeserializingUnflattener { DeserializingUnflattener { deserialize_buffer: deserialize_buffer } } } - pub impl> - SerializingFlattener { - - static fn new(serialize_value: SerializeValue - ) -> SerializingFlattener { + pub impl> SerializingFlattener { + static fn new(serialize_value: SerializeValue) + -> SerializingFlattener { SerializingFlattener { serialize_value: serialize_value } @@ -523,7 +519,7 @@ pub mod bytepipes { writer: W } - pub impl ReaderBytePort: BytePort { + pub impl BytePort for ReaderBytePort { fn try_recv(&self, count: uint) -> Option<~[u8]> { let mut left = count; let mut bytes = ~[]; @@ -545,7 +541,7 @@ pub mod bytepipes { } } - pub impl WriterByteChan: ByteChan { + pub impl ByteChan for WriterByteChan { fn send(&self, val: ~[u8]) { self.writer.write(val); } @@ -576,7 +572,7 @@ pub mod bytepipes { chan: pipes::Chan<~[u8]> } - pub impl PipeBytePort: BytePort { + pub impl BytePort for PipeBytePort { fn try_recv(&self, count: uint) -> Option<~[u8]> { if self.buf.len() >= count { let mut bytes = ::core::util::replace(&mut self.buf, ~[]); @@ -608,7 +604,7 @@ pub mod bytepipes { } } - pub impl PipeByteChan: ByteChan { + pub impl ByteChan for PipeByteChan { fn send(&self, val: ~[u8]) { self.chan.send(val) } diff --git a/src/libstd/json.rs b/src/libstd/json.rs index 5aa05e9cf75..e8278bb1b35 100644 --- a/src/libstd/json.rs +++ b/src/libstd/json.rs @@ -82,7 +82,7 @@ pub fn Encoder(wr: io::Writer) -> Encoder { Encoder { wr: wr } } -pub impl Encoder: serialize::Encoder { +pub impl serialize::Encoder for Encoder { fn emit_nil(&self) { self.wr.write_str("null") } fn emit_uint(&self, v: uint) { self.emit_float(v as float); } @@ -217,7 +217,7 @@ pub fn PrettyEncoder(wr: io::Writer) -> PrettyEncoder { PrettyEncoder { wr: wr, indent: 0 } } -pub impl PrettyEncoder: serialize::Encoder { +pub impl serialize::Encoder for PrettyEncoder { fn emit_nil(&self) { self.wr.write_str("null") } fn emit_uint(&self, v: uint) { self.emit_float(v as float); } @@ -323,7 +323,7 @@ pub impl PrettyEncoder: serialize::Encoder { } } -pub impl Json: serialize::Encodable { +pub impl serialize::Encodable for Json { fn encode(&self, s: &S) { match *self { Number(v) => v.encode(s), @@ -768,7 +768,7 @@ priv impl Decoder { } } -pub impl Decoder: serialize::Decoder { +pub impl serialize::Decoder for Decoder { fn read_nil(&self) -> () { debug!("read_nil"); match *self.pop() { diff --git a/src/libstd/prettyprint.rs b/src/libstd/prettyprint.rs index dc2e3d3da2b..cb9090225bf 100644 --- a/src/libstd/prettyprint.rs +++ b/src/libstd/prettyprint.rs @@ -22,7 +22,7 @@ pub fn Serializer(wr: io::Writer) -> Serializer { Serializer { wr: wr } } -pub impl Serializer: serialize::Encoder { +pub impl serialize::Encoder for Serializer { fn emit_nil(&self) { self.wr.write_str(~"()") } diff --git a/src/libstd/serialize.rs b/src/libstd/serialize.rs index d4afdbf6f30..9b7cf8adce5 100644 --- a/src/libstd/serialize.rs +++ b/src/libstd/serialize.rs @@ -113,210 +113,210 @@ pub trait Decodable { static fn decode(&self, d: &D) -> Self; } -pub impl uint: Encodable { +pub impl Encodable for uint { fn encode(&self, s: &S) { s.emit_uint(*self) } } -pub impl uint: Decodable { +pub impl Decodable for uint { static fn decode(&self, d: &D) -> uint { d.read_uint() } } -pub impl u8: Encodable { +pub impl Encodable for u8 { fn encode(&self, s: &S) { s.emit_u8(*self) } } -pub impl u8: Decodable { +pub impl Decodable for u8 { static fn decode(&self, d: &D) -> u8 { d.read_u8() } } -pub impl u16: Encodable { +pub impl Encodable for u16 { fn encode(&self, s: &S) { s.emit_u16(*self) } } -pub impl u16: Decodable { +pub impl Decodable for u16 { static fn decode(&self, d: &D) -> u16 { d.read_u16() } } -pub impl u32: Encodable { +pub impl Encodable for u32 { fn encode(&self, s: &S) { s.emit_u32(*self) } } -pub impl u32: Decodable { +pub impl Decodable for u32 { static fn decode(&self, d: &D) -> u32 { d.read_u32() } } -pub impl u64: Encodable { +pub impl Encodable for u64 { fn encode(&self, s: &S) { s.emit_u64(*self) } } -pub impl u64: Decodable { +pub impl Decodable for u64 { static fn decode(&self, d: &D) -> u64 { d.read_u64() } } -pub impl int: Encodable { +pub impl Encodable for int { fn encode(&self, s: &S) { s.emit_int(*self) } } -pub impl int: Decodable { +pub impl Decodable for int { static fn decode(&self, d: &D) -> int { d.read_int() } } -pub impl i8: Encodable { +pub impl Encodable for i8 { fn encode(&self, s: &S) { s.emit_i8(*self) } } -pub impl i8: Decodable { +pub impl Decodable for i8 { static fn decode(&self, d: &D) -> i8 { d.read_i8() } } -pub impl i16: Encodable { +pub impl Encodable for i16 { fn encode(&self, s: &S) { s.emit_i16(*self) } } -pub impl i16: Decodable { +pub impl Decodable for i16 { static fn decode(&self, d: &D) -> i16 { d.read_i16() } } -pub impl i32: Encodable { +pub impl Encodable for i32 { fn encode(&self, s: &S) { s.emit_i32(*self) } } -pub impl i32: Decodable { +pub impl Decodable for i32 { static fn decode(&self, d: &D) -> i32 { d.read_i32() } } -pub impl i64: Encodable { +pub impl Encodable for i64 { fn encode(&self, s: &S) { s.emit_i64(*self) } } -pub impl i64: Decodable { +pub impl Decodable for i64 { static fn decode(&self, d: &D) -> i64 { d.read_i64() } } -pub impl &str: Encodable { +pub impl Encodable for &str { fn encode(&self, s: &S) { s.emit_borrowed_str(*self) } } -pub impl ~str: Encodable { +pub impl Encodable for ~str { fn encode(&self, s: &S) { s.emit_owned_str(*self) } } -pub impl ~str: Decodable { +pub impl Decodable for ~str { static fn decode(&self, d: &D) -> ~str { d.read_owned_str() } } -pub impl @str: Encodable { +pub impl Encodable for @str { fn encode(&self, s: &S) { s.emit_managed_str(*self) } } -pub impl @str: Decodable { +pub impl Decodable for @str { static fn decode(&self, d: &D) -> @str { d.read_managed_str() } } -pub impl float: Encodable { +pub impl Encodable for float { fn encode(&self, s: &S) { s.emit_float(*self) } } -pub impl float: Decodable { +pub impl Decodable for float { static fn decode(&self, d: &D) -> float { d.read_float() } } -pub impl f32: Encodable { +pub impl Encodable for f32 { fn encode(&self, s: &S) { s.emit_f32(*self) } } -pub impl f32: Decodable { +pub impl Decodable for f32 { static fn decode(&self, d: &D) -> f32 { d.read_f32() } } -pub impl f64: Encodable { +pub impl Encodable for f64 { fn encode(&self, s: &S) { s.emit_f64(*self) } } -pub impl f64: Decodable { +pub impl Decodable for f64 { static fn decode(&self, d: &D) -> f64 { d.read_f64() } } -pub impl bool: Encodable { +pub impl Encodable for bool { fn encode(&self, s: &S) { s.emit_bool(*self) } } -pub impl bool: Decodable { +pub impl Decodable for bool { static fn decode(&self, d: &D) -> bool { d.read_bool() } } -pub impl (): Encodable { +pub impl Encodable for () { fn encode(&self, s: &S) { s.emit_nil() } } -pub impl (): Decodable { +pub impl Decodable for () { static fn decode(&self, d: &D) -> () { d.read_nil() } } -pub impl> &T: Encodable { +pub impl> Encodable for &T { fn encode(&self, s: &S) { s.emit_borrowed(|| (**self).encode(s)) } } -pub impl> ~T: Encodable { +pub impl> Encodable for ~T { fn encode(&self, s: &S) { s.emit_owned(|| (**self).encode(s)) } } -pub impl> ~T: Decodable { +pub impl> Decodable for ~T { static fn decode(&self, d: &D) -> ~T { d.read_owned(|| ~Decodable::decode(d)) } } -pub impl> @T: Encodable { +pub impl> Encodable for @T { fn encode(&self, s: &S) { s.emit_managed(|| (**self).encode(s)) } } -pub impl> @T: Decodable { +pub impl> Decodable for @T { static fn decode(&self, d: &D) -> @T { d.read_managed(|| @Decodable::decode(d)) } } -pub impl> &[T]: Encodable { +pub impl> Encodable for &[T] { fn encode(&self, s: &S) { do s.emit_borrowed_vec(self.len()) { for self.eachi |i, e| { @@ -326,7 +326,7 @@ pub impl> &[T]: Encodable { } } -pub impl> ~[T]: Encodable { +pub impl> Encodable for ~[T] { fn encode(&self, s: &S) { do s.emit_owned_vec(self.len()) { for self.eachi |i, e| { @@ -336,7 +336,7 @@ pub impl> ~[T]: Encodable { } } -pub impl> ~[T]: Decodable { +pub impl> Decodable for ~[T] { static fn decode(&self, d: &D) -> ~[T] { do d.read_owned_vec |len| { do vec::from_fn(len) |i| { @@ -346,7 +346,7 @@ pub impl> ~[T]: Decodable { } } -pub impl> @[T]: Encodable { +pub impl> Encodable for @[T] { fn encode(&self, s: &S) { do s.emit_managed_vec(self.len()) { for self.eachi |i, e| { @@ -356,7 +356,7 @@ pub impl> @[T]: Encodable { } } -pub impl> @[T]: Decodable { +pub impl> Decodable for @[T] { static fn decode(&self, d: &D) -> @[T] { do d.read_managed_vec |len| { do at_vec::from_fn(len) |i| { @@ -366,7 +366,7 @@ pub impl> @[T]: Decodable { } } -pub impl> Option: Encodable { +pub impl> Encodable for Option { fn encode(&self, s: &S) { do s.emit_enum(~"option") { match *self { @@ -381,7 +381,7 @@ pub impl> Option: Encodable { } } -pub impl> Option: Decodable { +pub impl> Decodable for Option { static fn decode(&self, d: &D) -> Option { do d.read_enum(~"option") { do d.read_enum_variant |i| { @@ -396,11 +396,8 @@ pub impl> Option: Decodable { } } -pub impl< - S: Encoder, - T0: Encodable, - T1: Encodable -> (T0, T1): Encodable { +pub impl, T1: Encodable> Encodable + for (T0, T1) { fn encode(&self, s: &S) { match *self { (ref t0, ref t1) => { @@ -413,11 +410,8 @@ pub impl< } } -pub impl< - D: Decoder, - T0: Decodable, - T1: Decodable -> (T0, T1): Decodable { +pub impl, T1: Decodable> Decodable + for (T0, T1) { static fn decode(&self, d: &D) -> (T0, T1) { do d.read_tup(2) { ( @@ -433,7 +427,7 @@ pub impl< T0: Encodable, T1: Encodable, T2: Encodable -> (T0, T1, T2): Encodable { +> Encodable for (T0, T1, T2) { fn encode(&self, s: &S) { match *self { (ref t0, ref t1, ref t2) => { @@ -452,7 +446,7 @@ pub impl< T0: Decodable, T1: Decodable, T2: Decodable -> (T0, T1, T2): Decodable { +> Decodable for (T0, T1, T2) { static fn decode(&self, d: &D) -> (T0, T1, T2) { do d.read_tup(3) { ( @@ -470,7 +464,7 @@ pub impl< T1: Encodable, T2: Encodable, T3: Encodable -> (T0, T1, T2, T3): Encodable { +> Encodable for (T0, T1, T2, T3) { fn encode(&self, s: &S) { match *self { (ref t0, ref t1, ref t2, ref t3) => { @@ -491,7 +485,7 @@ pub impl< T1: Decodable, T2: Decodable, T3: Decodable -> (T0, T1, T2, T3): Decodable { +> Decodable for (T0, T1, T2, T3) { static fn decode(&self, d: &D) -> (T0, T1, T2, T3) { do d.read_tup(4) { ( @@ -511,7 +505,7 @@ pub impl< T2: Encodable, T3: Encodable, T4: Encodable -> (T0, T1, T2, T3, T4): Encodable { +> Encodable for (T0, T1, T2, T3, T4) { fn encode(&self, s: &S) { match *self { (ref t0, ref t1, ref t2, ref t3, ref t4) => { @@ -534,7 +528,7 @@ pub impl< T2: Decodable, T3: Decodable, T4: Decodable -> (T0, T1, T2, T3, T4): Decodable { +> Decodable for (T0, T1, T2, T3, T4) { static fn decode(&self, d: &D) -> (T0, T1, T2, T3, T4) { do d.read_tup(5) { @@ -558,7 +552,7 @@ pub trait EncoderHelpers { fn emit_from_vec(&self, v: &[T], f: fn(v: &T)); } -pub impl S: EncoderHelpers { +pub impl EncoderHelpers for S { fn emit_from_vec(&self, v: &[T], f: fn(v: &T)) { do self.emit_owned_vec(v.len()) { for v.eachi |i, e| { @@ -574,7 +568,7 @@ pub trait DecoderHelpers { fn read_to_vec(&self, f: fn() -> T) -> ~[T]; } -pub impl D: DecoderHelpers { +pub impl DecoderHelpers for D { fn read_to_vec(&self, f: fn() -> T) -> ~[T] { do self.read_owned_vec |len| { do vec::from_fn(len) |i| { diff --git a/src/libstd/workcache.rs b/src/libstd/workcache.rs index cb0f7d84b41..70c03c69d2d 100644 --- a/src/libstd/workcache.rs +++ b/src/libstd/workcache.rs @@ -138,7 +138,7 @@ impl WorkKey { type WorkMap = LinearMap; -pub impl WorkMap: Encodable { +pub impl Encodable for WorkMap { fn encode(&self, s: &S) { let mut d = ~[]; for self.each |&(k, v)| { @@ -149,7 +149,7 @@ pub impl WorkMap: Encodable { } } -pub impl WorkMap: Decodable { +pub impl Decodable for WorkMap { static fn decode(&self, d: &D) -> WorkMap { let v : ~[(WorkKey,~str)] = Decodable::decode(d); let mut w = LinearMap::new(); diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 053df524bf7..14a66a49df3 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -32,7 +32,7 @@ macro_rules! interner_key ( #[deriving_eq] pub struct ident { repr: uint } -pub impl ident: Encodable { +pub impl Encodable for ident { fn encode(&self, s: &S) { let intr = match unsafe { task::local_data::local_data_get(interner_key!()) @@ -45,7 +45,7 @@ pub impl ident: Encodable { } } -pub impl ident: Decodable { +pub impl Decodable for ident { static fn decode(d: &D) -> ident { let intr = match unsafe { task::local_data::local_data_get(interner_key!()) @@ -58,7 +58,7 @@ pub impl ident: Decodable { } } -pub impl ident: to_bytes::IterBytes { +pub impl to_bytes::IterBytes for ident { pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { self.repr.iter_bytes(lsb0, f) } @@ -211,7 +211,7 @@ pub enum binding_mode { bind_infer } -pub impl binding_mode : to_bytes::IterBytes { +pub impl to_bytes::IterBytes for binding_mode { pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { match *self { bind_by_copy => 0u8.iter_bytes(lsb0, f), @@ -256,7 +256,7 @@ pub enum pat_ { #[deriving_eq] pub enum mutability { m_mutbl, m_imm, m_const, } -pub impl mutability : to_bytes::IterBytes { +pub impl to_bytes::IterBytes for mutability { pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { (*self as u8).iter_bytes(lsb0, f) } @@ -269,13 +269,13 @@ pub enum Abi { RustAbi } -pub impl Abi : to_bytes::IterBytes { +pub impl to_bytes::IterBytes for Abi { pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { (*self as uint).iter_bytes(lsb0, f) } } -pub impl Abi : ToStr { +pub impl ToStr for Abi { pure fn to_str(&self) -> ~str { match *self { RustAbi => ~"\"rust\"" @@ -292,13 +292,13 @@ pub enum Sigil { ManagedSigil } -pub impl Sigil : to_bytes::IterBytes { +pub impl to_bytes::IterBytes for Sigil { pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { (*self as uint).iter_bytes(lsb0, f) } } -pub impl Sigil : ToStr { +pub impl ToStr for Sigil { pure fn to_str(&self) -> ~str { match *self { BorrowedSigil => ~"&", @@ -377,7 +377,7 @@ pub enum inferable { infer(node_id) } -pub impl inferable : to_bytes::IterBytes { +pub impl to_bytes::IterBytes for inferable { pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { match *self { expl(ref t) => @@ -395,7 +395,7 @@ pub impl inferable : to_bytes::IterBytes { #[deriving_eq] pub enum rmode { by_ref, by_val, by_copy } -pub impl rmode : to_bytes::IterBytes { +pub impl to_bytes::IterBytes for rmode { pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { (*self as u8).iter_bytes(lsb0, f) } @@ -736,13 +736,13 @@ pub enum trait_method { #[deriving_eq] pub enum int_ty { ty_i, ty_char, ty_i8, ty_i16, ty_i32, ty_i64, } -pub impl int_ty : ToStr { +pub impl ToStr for int_ty { pure fn to_str(&self) -> ~str { ::ast_util::int_ty_to_str(*self) } } -pub impl int_ty : to_bytes::IterBytes { +pub impl to_bytes::IterBytes for int_ty { pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { (*self as u8).iter_bytes(lsb0, f) } @@ -753,13 +753,13 @@ pub impl int_ty : to_bytes::IterBytes { #[deriving_eq] pub enum uint_ty { ty_u, ty_u8, ty_u16, ty_u32, ty_u64, } -pub impl uint_ty : ToStr { +pub impl ToStr for uint_ty { pure fn to_str(&self) -> ~str { ::ast_util::uint_ty_to_str(*self) } } -pub impl uint_ty : to_bytes::IterBytes { +pub impl to_bytes::IterBytes for uint_ty { pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { (*self as u8).iter_bytes(lsb0, f) } @@ -770,13 +770,13 @@ pub impl uint_ty : to_bytes::IterBytes { #[deriving_eq] pub enum float_ty { ty_f, ty_f32, ty_f64, } -pub impl float_ty : ToStr { +pub impl ToStr for float_ty { pure fn to_str(&self) -> ~str { ::ast_util::float_ty_to_str(*self) } } -pub impl float_ty : to_bytes::IterBytes { +pub impl to_bytes::IterBytes for float_ty { pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { (*self as u8).iter_bytes(lsb0, f) } @@ -830,7 +830,7 @@ pub enum Onceness { Many } -pub impl Onceness : ToStr { +pub impl ToStr for Onceness { pure fn to_str(&self) -> ~str { match *self { Once => ~"once", @@ -839,7 +839,7 @@ pub impl Onceness : ToStr { } } -pub impl Onceness : to_bytes::IterBytes { +pub impl to_bytes::IterBytes for Onceness { pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { (*self as uint).iter_bytes(lsb0, f); } @@ -889,7 +889,7 @@ pub enum ty_ { ty_infer, } -pub impl Ty : to_bytes::IterBytes { +pub impl to_bytes::IterBytes for Ty { pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { to_bytes::iter_bytes_2(&self.span.lo, &self.span.hi, lsb0, f); } @@ -925,7 +925,7 @@ pub enum purity { extern_fn, // declared with "extern fn" } -pub impl purity : ToStr { +pub impl ToStr for purity { pure fn to_str(&self) -> ~str { match *self { impure_fn => ~"impure", @@ -936,7 +936,7 @@ pub impl purity : ToStr { } } -pub impl purity : to_bytes::IterBytes { +pub impl to_bytes::IterBytes for purity { pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { (*self as u8).iter_bytes(lsb0, f) } @@ -951,7 +951,7 @@ pub enum ret_style { return_val, // everything else } -pub impl ret_style : to_bytes::IterBytes { +pub impl to_bytes::IterBytes for ret_style { pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { (*self as u8).iter_bytes(lsb0, f) } @@ -1232,7 +1232,7 @@ pub enum item_ { #[deriving_eq] pub enum struct_mutability { struct_mutable, struct_immutable } -pub impl struct_mutability : to_bytes::IterBytes { +pub impl to_bytes::IterBytes for struct_mutability { pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { (*self as u8).iter_bytes(lsb0, f) } diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs index 9eeee943f8b..108a0dfc5e0 100644 --- a/src/libsyntax/ast_map.rs +++ b/src/libsyntax/ast_map.rs @@ -34,7 +34,7 @@ pub enum path_elt { path_name(ident) } -pub impl path_elt : cmp::Eq { +pub impl cmp::Eq for path_elt { pure fn eq(&self, other: &path_elt) -> bool { match (*self) { path_mod(e0a) => { diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs index 335dd4e3fa2..f7ae2058095 100644 --- a/src/libsyntax/ast_util.rs +++ b/src/libsyntax/ast_util.rs @@ -198,7 +198,7 @@ pub pure fn is_call_expr(e: @expr) -> bool { } // This makes def_id hashable -pub impl def_id : to_bytes::IterBytes { +pub impl to_bytes::IterBytes for def_id { #[inline(always)] pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { to_bytes::iter_bytes_2(&self.crate, &self.node, lsb0, f); @@ -303,7 +303,7 @@ pub trait inlined_item_utils { fn accept(&self, e: E, v: visit::vt); } -pub impl inlined_item: inlined_item_utils { +pub impl inlined_item_utils for inlined_item { fn ident(&self) -> ident { match *self { ii_item(i) => /* FIXME (#2543) */ copy i.ident, diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs index 3c61e834af6..851b35ca3bd 100644 --- a/src/libsyntax/codemap.rs +++ b/src/libsyntax/codemap.rs @@ -46,71 +46,71 @@ pub enum CharPos = uint; // XXX: Lots of boilerplate in these impls, but so far my attempts to fix // have been unsuccessful -pub impl BytePos: Pos { +pub impl Pos for BytePos { static pure fn from_uint(n: uint) -> BytePos { BytePos(n) } pure fn to_uint(&self) -> uint { **self } } -pub impl BytePos: cmp::Eq { +pub impl cmp::Eq for BytePos { pure fn eq(&self, other: &BytePos) -> bool { **self == **other } pure fn ne(&self, other: &BytePos) -> bool { !(*self).eq(other) } } -pub impl BytePos: cmp::Ord { +pub impl cmp::Ord for BytePos { pure fn lt(&self, other: &BytePos) -> bool { **self < **other } pure fn le(&self, other: &BytePos) -> bool { **self <= **other } pure fn ge(&self, other: &BytePos) -> bool { **self >= **other } pure fn gt(&self, other: &BytePos) -> bool { **self > **other } } -pub impl BytePos: Add { +pub impl Add for BytePos { pure fn add(&self, rhs: &BytePos) -> BytePos { BytePos(**self + **rhs) } } -pub impl BytePos: Sub { +pub impl Sub for BytePos { pure fn sub(&self, rhs: &BytePos) -> BytePos { BytePos(**self - **rhs) } } -pub impl BytePos: to_bytes::IterBytes { +pub impl to_bytes::IterBytes for BytePos { pure fn iter_bytes(&self, +lsb0: bool, &&f: to_bytes::Cb) { (**self).iter_bytes(lsb0, f) } } -pub impl CharPos: Pos { +pub impl Pos for CharPos { static pure fn from_uint(n: uint) -> CharPos { CharPos(n) } pure fn to_uint(&self) -> uint { **self } } -pub impl CharPos: cmp::Eq { +pub impl cmp::Eq for CharPos { pure fn eq(&self, other: &CharPos) -> bool { **self == **other } pure fn ne(&self, other: &CharPos) -> bool { !(*self).eq(other) } } -pub impl CharPos: cmp::Ord { +pub impl cmp::Ord for CharPos { pure fn lt(&self, other: &CharPos) -> bool { **self < **other } pure fn le(&self, other: &CharPos) -> bool { **self <= **other } pure fn ge(&self, other: &CharPos) -> bool { **self >= **other } pure fn gt(&self, other: &CharPos) -> bool { **self > **other } } -pub impl CharPos: to_bytes::IterBytes { +pub impl to_bytes::IterBytes for CharPos { pure fn iter_bytes(&self, +lsb0: bool, &&f: to_bytes::Cb) { (**self).iter_bytes(lsb0, f) } } -pub impl CharPos: Add { +pub impl Add for CharPos { pure fn add(&self, rhs: &CharPos) -> CharPos { CharPos(**self + **rhs) } } -pub impl CharPos: Sub { +pub impl Sub for CharPos { pure fn sub(&self, rhs: &CharPos) -> CharPos { CharPos(**self - **rhs) } @@ -133,19 +133,19 @@ pub struct span { #[deriving_eq] pub struct spanned { node: T, span: span } -pub impl span : cmp::Eq { +pub impl cmp::Eq for span { pure fn eq(&self, other: &span) -> bool { return (*self).lo == (*other).lo && (*self).hi == (*other).hi; } pure fn ne(&self, other: &span) -> bool { !(*self).eq(other) } } -pub impl span: Encodable { +pub impl Encodable for span { /* Note #1972 -- spans are encoded but not decoded */ fn encode(&self, _s: &S) { } } -pub impl span: Decodable { +pub impl Decodable for span { static fn decode(_d: &D) -> span { dummy_sp() } diff --git a/src/libsyntax/ext/pipes/ast_builder.rs b/src/libsyntax/ext/pipes/ast_builder.rs index 58ab05987a6..12e5f1891aa 100644 --- a/src/libsyntax/ext/pipes/ast_builder.rs +++ b/src/libsyntax/ext/pipes/ast_builder.rs @@ -54,7 +54,7 @@ pub trait append_types { fn add_tys(+tys: ~[@ast::Ty]) -> @ast::path; } -pub impl @ast::path: append_types { +pub impl append_types for @ast::path { fn add_ty(ty: @ast::Ty) -> @ast::path { @ast::path { types: vec::append_one(self.types, ty), .. *self} @@ -112,7 +112,7 @@ pub trait ext_ctxt_ast_builder { fn strip_bounds(bounds: &[ast::ty_param]) -> ~[ast::ty_param]; } -pub impl ext_ctxt: ext_ctxt_ast_builder { +pub impl ext_ctxt_ast_builder for ext_ctxt { fn ty_option(ty: @ast::Ty) -> @ast::Ty { self.ty_path_ast_builder(path_global(~[ self.ident_of(~"core"), diff --git a/src/libsyntax/ext/pipes/check.rs b/src/libsyntax/ext/pipes/check.rs index cde6a581dce..a8e0b3ba934 100644 --- a/src/libsyntax/ext/pipes/check.rs +++ b/src/libsyntax/ext/pipes/check.rs @@ -37,7 +37,7 @@ use ext::base::ext_ctxt; use ext::pipes::proto::{state, protocol, next_state}; use ext::pipes::proto; -pub impl ext_ctxt: proto::visitor<(), (), ()> { +pub impl proto::visitor<(), (), ()> for ext_ctxt { fn visit_proto(_proto: protocol, _states: &[()]) { } diff --git a/src/libsyntax/ext/pipes/parse_proto.rs b/src/libsyntax/ext/pipes/parse_proto.rs index 6a1708b8e2b..87561047470 100644 --- a/src/libsyntax/ext/pipes/parse_proto.rs +++ b/src/libsyntax/ext/pipes/parse_proto.rs @@ -22,7 +22,7 @@ pub trait proto_parser { fn parse_message(state: state); } -pub impl parser::Parser: proto_parser { +pub impl proto_parser for parser::Parser { fn parse_proto(id: ~str) -> protocol { let proto = protocol(id, self.span); diff --git a/src/libsyntax/ext/pipes/pipec.rs b/src/libsyntax/ext/pipes/pipec.rs index 0f596e66158..68d18a2937c 100644 --- a/src/libsyntax/ext/pipes/pipec.rs +++ b/src/libsyntax/ext/pipes/pipec.rs @@ -45,7 +45,7 @@ pub trait gen_init { fn gen_init_bounded(ext_cx: ext_ctxt) -> @ast::expr; } -pub impl message: gen_send { +pub impl gen_send for message { fn gen_send(cx: ext_ctxt, try: bool) -> @ast::item { debug!("pipec: gen_send"); match self { @@ -201,7 +201,7 @@ pub impl message: gen_send { } } -pub impl state: to_type_decls { +pub impl to_type_decls for state { fn to_type_decls(cx: ext_ctxt) -> ~[@ast::item] { debug!("pipec: to_type_decls"); // This compiles into two different type declarations. Say the @@ -305,8 +305,7 @@ pub impl state: to_type_decls { } } -pub impl protocol: gen_init { - +pub impl gen_init for protocol { fn gen_init(cx: ext_ctxt) -> @ast::item { let ext_cx = cx; diff --git a/src/libsyntax/ext/pipes/proto.rs b/src/libsyntax/ext/pipes/proto.rs index 1d6534aef34..027375b6326 100644 --- a/src/libsyntax/ext/pipes/proto.rs +++ b/src/libsyntax/ext/pipes/proto.rs @@ -21,7 +21,7 @@ use core::to_str::ToStr; pub enum direction { send, recv } -pub impl direction : cmp::Eq { +pub impl cmp::Eq for direction { pure fn eq(&self, other: &direction) -> bool { match ((*self), (*other)) { (send, send) => true, @@ -33,7 +33,7 @@ pub impl direction : cmp::Eq { pure fn ne(&self, other: &direction) -> bool { !(*self).eq(other) } } -pub impl direction: ToStr { +pub impl ToStr for direction { pure fn to_str(&self) -> ~str { match *self { send => ~"Send", @@ -156,7 +156,6 @@ pub struct protocol_ { } pub impl protocol_ { - /// Get a state. fn get_state(name: ~str) -> state { self.states.find(|i| i.name == name).get() diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index ff9a353ee92..dc5d7916c7e 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -692,7 +692,7 @@ pub fn default_ast_fold() -> ast_fold_fns { new_span: noop_span}; } -pub impl ast_fold_fns: ast_fold { +pub impl ast_fold for ast_fold_fns { /* naturally, a macro to write these would be nice */ fn fold_crate(c: crate) -> crate { let (n, s) = (self.fold_crate)(c.node, c.span, self as ast_fold); diff --git a/src/libsyntax/parse/lexer.rs b/src/libsyntax/parse/lexer.rs index cb9382ebbb6..92c4f1e828f 100644 --- a/src/libsyntax/parse/lexer.rs +++ b/src/libsyntax/parse/lexer.rs @@ -127,7 +127,7 @@ impl reader for StringReader { fn dup(@mut self) -> reader { dup_string_reader(self) as reader } } -pub impl TtReader: reader { +pub impl reader for TtReader { fn is_eof(@mut self) -> bool { self.cur_tok == token::EOF } fn next_token(@mut self) -> TokenAndSpan { tt_next_token(self) } fn fatal(@mut self, m: ~str) -> ! { diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs index 1b4493b7ec9..bf04996838c 100644 --- a/src/libsyntax/parse/obsolete.rs +++ b/src/libsyntax/parse/obsolete.rs @@ -45,10 +45,11 @@ pub enum ObsoleteSyntax { ObsoleteMoveInit, ObsoleteBinaryMove, ObsoleteUnsafeBlock, - ObsoleteUnenforcedBound + ObsoleteUnenforcedBound, + ObsoleteImplSyntax } -pub impl ObsoleteSyntax: to_bytes::IterBytes { +pub impl to_bytes::IterBytes for ObsoleteSyntax { #[inline(always)] pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) { (*self as uint).iter_bytes(lsb0, f); @@ -115,6 +116,10 @@ pub impl Parser { "unenforced type parameter bound", "use trait bounds on the functions that take the type as \ arguments, not on the types themselves" + ), + ObsoleteImplSyntax => ( + "colon-separated impl syntax", + "write `impl Trait for Type`" ) }; diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index b4fd7a5d2e8..15258a6bbee 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -74,7 +74,7 @@ use parse::obsolete::{ObsoleteLet, ObsoleteFieldTerminator}; use parse::obsolete::{ObsoleteMoveInit, ObsoleteBinaryMove}; use parse::obsolete::{ObsoleteStructCtor, ObsoleteWith}; use parse::obsolete::{ObsoleteSyntax, ObsoleteLowerCaseKindBounds}; -use parse::obsolete::{ObsoleteUnsafeBlock}; +use parse::obsolete::{ObsoleteUnsafeBlock, ObsoleteImplSyntax}; use parse::prec::{as_prec, token_to_binop}; use parse::token::{can_begin_expr, is_ident, is_ident_or_path}; use parse::token::{is_plain_ident, INTERPOLATED, special_idents}; @@ -2829,16 +2829,11 @@ pub impl Parser { // XXX: clownshoes let ident = special_idents::clownshoes_extensions; - // Parse the type. (If this is `impl trait for type`, however, this - // actually parses the trait.) + // Parse the trait. let mut ty = self.parse_ty(false); // Parse traits, if necessary. - let opt_trait = if self.token == token::COLON { - // Old-style trait. - self.bump(); - Some(self.parse_trait_ref()) - } else if self.eat_keyword(~"for") { + let opt_trait = if self.eat_keyword(~"for") { // New-style trait. Reinterpret the type as a trait. let opt_trait_ref = match ty.node { ty_path(path, node_id) => { @@ -2855,6 +2850,9 @@ pub impl Parser { ty = self.parse_ty(false); opt_trait_ref + } else if self.eat(token::COLON) { + self.obsolete(copy self.span, ObsoleteImplSyntax); + Some(self.parse_trait_ref()) } else { None }; diff --git a/src/libsyntax/util/interner.rs b/src/libsyntax/util/interner.rs index 0677e25a3fe..657e6ee59fa 100644 --- a/src/libsyntax/util/interner.rs +++ b/src/libsyntax/util/interner.rs @@ -42,7 +42,7 @@ pub trait Interner { fn len() -> uint; } -pub impl hash_interner: Interner { +pub impl Interner for hash_interner { fn intern(val: T) -> uint { match self.map.find(&val) { Some(idx) => return idx, diff --git a/src/test/auxiliary/cci_class_cast.rs b/src/test/auxiliary/cci_class_cast.rs index c0140bff5b1..5256944b18e 100644 --- a/src/test/auxiliary/cci_class_cast.rs +++ b/src/test/auxiliary/cci_class_cast.rs @@ -17,7 +17,7 @@ pub mod kitty { name : ~str, } - pub impl cat : ToStr { + pub impl ToStr for cat { pure fn to_str(&self) -> ~str { copy self.name } } diff --git a/src/test/auxiliary/crate-method-reexport-grrrrrrr2.rs b/src/test/auxiliary/crate-method-reexport-grrrrrrr2.rs index 847b6d5b2bb..2b3fd47e5bc 100644 --- a/src/test/auxiliary/crate-method-reexport-grrrrrrr2.rs +++ b/src/test/auxiliary/crate-method-reexport-grrrrrrr2.rs @@ -19,7 +19,7 @@ pub mod name_pool { fn add(s: ~str); } - pub impl name_pool: add { + pub impl add for name_pool { fn add(s: ~str) { } } @@ -34,7 +34,7 @@ pub mod rust { fn cx(); } - pub impl rt: cx { + pub impl cx for rt { fn cx() { } } diff --git a/src/test/auxiliary/issue-3012-1.rs b/src/test/auxiliary/issue-3012-1.rs index 618b9391ba1..cbc1c4b2fec 100644 --- a/src/test/auxiliary/issue-3012-1.rs +++ b/src/test/auxiliary/issue-3012-1.rs @@ -16,7 +16,7 @@ pub mod socket { sockfd: libc::c_int, } - pub impl socket_handle : Drop { + pub impl Drop for socket_handle { fn finalize(&self) { /* c::close(self.sockfd); */ } diff --git a/src/test/auxiliary/issue2170lib.rs b/src/test/auxiliary/issue2170lib.rs index bf5a6643204..d664ad62edf 100644 --- a/src/test/auxiliary/issue2170lib.rs +++ b/src/test/auxiliary/issue2170lib.rs @@ -15,7 +15,7 @@ pub struct rsrc { x: i32, } -pub impl rsrc : Drop { +pub impl Drop for rsrc { fn finalize(&self) { foo(self.x); } diff --git a/src/test/auxiliary/trait_inheritance_overloading_xc.rs b/src/test/auxiliary/trait_inheritance_overloading_xc.rs index 950f4b6bbe7..2ed3b3b1f5c 100644 --- a/src/test/auxiliary/trait_inheritance_overloading_xc.rs +++ b/src/test/auxiliary/trait_inheritance_overloading_xc.rs @@ -17,25 +17,25 @@ pub struct MyInt { val: int } -pub impl MyInt : Add { +pub impl Add for MyInt { pure fn add(&self, other: &MyInt) -> MyInt { mi(self.val + other.val) } } -pub impl MyInt : Sub { +pub impl Sub for MyInt { pure fn sub(&self, other: &MyInt) -> MyInt { mi(self.val - other.val) } } -pub impl MyInt : Mul { +pub impl Mul for MyInt { pure fn mul(&self, other: &MyInt) -> MyInt { mi(self.val * other.val) } } -pub impl MyInt : Eq { +pub impl Eq for MyInt { pure fn eq(&self, other: &MyInt) -> bool { self.val == other.val } pure fn ne(&self, other: &MyInt) -> bool { !self.eq(other) } } -pub impl MyInt : MyNum; +pub impl MyNum for MyInt; pure fn mi(v: int) -> MyInt { MyInt { val: v } } diff --git a/src/test/compile-fail/issue-3953.rs b/src/test/compile-fail/issue-3953.rs index 2c797691b8d..227ea5c1521 100644 --- a/src/test/compile-fail/issue-3953.rs +++ b/src/test/compile-fail/issue-3953.rs @@ -19,7 +19,7 @@ trait Hahaha: Eq Eq Eq Eq Eq Eq Eq Eq Eq Eq Eq Eq Eq Eq Eq Eq //~ ERROR Duplicat enum Lol = int; -pub impl Lol: Hahaha { } +pub impl Hahaha for Lol { } impl Eq for Lol { pure fn eq(&self, other: &Lol) -> bool { **self != **other } diff --git a/src/test/compile-fail/issue-3969.rs b/src/test/compile-fail/issue-3969.rs index 675544ea59f..a0035639287 100644 --- a/src/test/compile-fail/issue-3969.rs +++ b/src/test/compile-fail/issue-3969.rs @@ -16,7 +16,7 @@ trait BikeMethods { fn woops(&const self) -> ~str; } -pub impl Bike : BikeMethods { +pub impl BikeMethods for Bike { static fn woops(&const self) -> ~str { ~"foo" } //~^ ERROR method `woops` is declared as static in its impl, but not in its trait } diff --git a/src/test/compile-fail/missing-derivable-attr.rs b/src/test/compile-fail/missing-derivable-attr.rs index 3d63b622fcc..057e6dbc068 100644 --- a/src/test/compile-fail/missing-derivable-attr.rs +++ b/src/test/compile-fail/missing-derivable-attr.rs @@ -20,7 +20,7 @@ impl MyEq for int { pure fn eq(&self, other: &int) -> bool { *self == *other } } -impl A : MyEq; //~ ERROR missing method +impl MyEq for A; //~ ERROR missing method fn main() { } diff --git a/src/test/run-pass/issue-2718.rs b/src/test/run-pass/issue-2718.rs index ba7cf0cc45f..8472f0158bb 100644 --- a/src/test/run-pass/issue-2718.rs +++ b/src/test/run-pass/issue-2718.rs @@ -20,6 +20,7 @@ pub mod pipes { mut payload: Option } + #[deriving_eq] pub enum state { empty, full, @@ -27,13 +28,6 @@ pub mod pipes { terminated } - pub impl state : cmp::Eq { - pure fn eq(&self, other: &state) -> bool { - ((*self) as uint) == ((*other) as uint) - } - pure fn ne(&self, other: &state) -> bool { !(*self).eq(other) } - } - pub type packet = { mut state: state, mut blocked_task: Option, @@ -161,7 +155,7 @@ pub mod pipes { mut p: Option<*packet>, } - pub impl send_packet : Drop { + pub impl Drop for send_packet { fn finalize(&self) { if self.p != None { let mut p = None; @@ -189,7 +183,7 @@ pub mod pipes { mut p: Option<*packet>, } - pub impl recv_packet : Drop { + pub impl Drop for recv_packet { fn finalize(&self) { if self.p != None { let mut p = None; diff --git a/src/test/run-pass/issue-3563-3.rs b/src/test/run-pass/issue-3563-3.rs index 88f31189a0c..c4f4aa46a8a 100644 --- a/src/test/run-pass/issue-3563-3.rs +++ b/src/test/run-pass/issue-3563-3.rs @@ -23,8 +23,7 @@ extern mod std; use io::WriterUtil; // Represents a position on a canvas. -struct Point -{ +struct Point { x: int, y: int, } @@ -108,8 +107,7 @@ impl AsciiArt // Allows AsciiArt to be converted to a string using the libcore ToStr trait. // Note that the %s fmt! specifier will not call this automatically. -impl AsciiArt : ToStr -{ +impl ToStr for AsciiArt { pure fn to_str(&self) -> ~str { // Convert each line into a string. @@ -139,8 +137,7 @@ trait Canvas // Here we provide an implementation of the Canvas methods for AsciiArt. // Other implementations could also be provided (e.g. for PDF or Apple's Quartz) // and code can use them polymorphically via the Canvas trait. -impl AsciiArt : Canvas -{ +impl Canvas for AsciiArt { fn add_point(&mut self, shape: Point) { self.add_pt(shape.x, shape.y); diff --git a/src/test/run-pass/issue-3979.rs b/src/test/run-pass/issue-3979.rs index 3ea2ef83296..5d48d1e72de 100644 --- a/src/test/run-pass/issue-3979.rs +++ b/src/test/run-pass/issue-3979.rs @@ -31,7 +31,7 @@ impl Positioned for Point { } } -impl Point: Movable; +impl Movable for Point; pub fn main() { let p = Point{ x: 1, y: 2}; diff --git a/src/test/run-pass/pipe-presentation-examples.rs b/src/test/run-pass/pipe-presentation-examples.rs index 5fd1bb276c1..7ac6337d1ca 100644 --- a/src/test/run-pass/pipe-presentation-examples.rs +++ b/src/test/run-pass/pipe-presentation-examples.rs @@ -81,7 +81,7 @@ pub struct Buffer { } -pub impl Buffer : Drop { +pub impl Drop for Buffer { fn finalize(&self) {} } diff --git a/src/test/run-pass/static-impl.rs b/src/test/run-pass/static-impl.rs index 870059d1edc..5e7785c2dbb 100644 --- a/src/test/run-pass/static-impl.rs +++ b/src/test/run-pass/static-impl.rs @@ -17,12 +17,12 @@ pub trait plus { mod a { use plus; - pub impl uint: plus { fn plus() -> int { self as int + 20 } } + pub impl plus for uint { fn plus() -> int { self as int + 20 } } } mod b { use plus; - pub impl ~str: plus { fn plus() -> int { 200 } } + pub impl plus for ~str { fn plus() -> int { 200 } } } trait uint_utils { diff --git a/src/test/run-pass/static-methods-in-traits2.rs b/src/test/run-pass/static-methods-in-traits2.rs index 8c61f60eaac..b4c28fd52a6 100644 --- a/src/test/run-pass/static-methods-in-traits2.rs +++ b/src/test/run-pass/static-methods-in-traits2.rs @@ -2,7 +2,7 @@ pub trait Number: NumConv { static pure fn from(n: T) -> Self; } -pub impl float: Number { +pub impl Number for float { static pure fn from(n: T) -> float { n.to_float() } } @@ -10,7 +10,7 @@ pub trait NumConv { pure fn to_float(&self) -> float; } -pub impl float: NumConv { +pub impl NumConv for float { pure fn to_float(&self) -> float { *self } } diff --git a/src/test/run-pass/trait-inheritance-num2.rs b/src/test/run-pass/trait-inheritance-num2.rs index fb2969a8398..64b30d71e1d 100644 --- a/src/test/run-pass/trait-inheritance-num2.rs +++ b/src/test/run-pass/trait-inheritance-num2.rs @@ -21,84 +21,84 @@ use std::cmp::FuzzyEq; pub trait TypeExt {} -pub impl u8: TypeExt {} -pub impl u16: TypeExt {} -pub impl u32: TypeExt {} -pub impl u64: TypeExt {} -pub impl uint: TypeExt {} +pub impl TypeExt for u8 {} +pub impl TypeExt for u16 {} +pub impl TypeExt for u32 {} +pub impl TypeExt for u64 {} +pub impl TypeExt for uint {} -pub impl i8: TypeExt {} -pub impl i16: TypeExt {} -pub impl i32: TypeExt {} -pub impl i64: TypeExt {} -pub impl int: TypeExt {} +pub impl TypeExt for i8 {} +pub impl TypeExt for i16 {} +pub impl TypeExt for i32 {} +pub impl TypeExt for i64 {} +pub impl TypeExt for int {} -pub impl f32: TypeExt {} -pub impl f64: TypeExt {} -pub impl float: TypeExt {} +pub impl TypeExt for f32 {} +pub impl TypeExt for f64 {} +pub impl TypeExt for float {} pub trait NumExt: TypeExt Eq Ord NumCast {} -pub impl u8: NumExt {} -pub impl u16: NumExt {} -pub impl u32: NumExt {} -pub impl u64: NumExt {} -pub impl uint: NumExt {} +pub impl NumExt for u8 {} +pub impl NumExt for u16 {} +pub impl NumExt for u32 {} +pub impl NumExt for u64 {} +pub impl NumExt for uint {} -pub impl i8: NumExt {} -pub impl i16: NumExt {} -pub impl i32: NumExt {} -pub impl i64: NumExt {} -pub impl int: NumExt {} +pub impl NumExt for i8 {} +pub impl NumExt for i16 {} +pub impl NumExt for i32 {} +pub impl NumExt for i64 {} +pub impl NumExt for int {} -pub impl f32: NumExt {} -pub impl f64: NumExt {} -pub impl float: NumExt {} +pub impl NumExt for f32 {} +pub impl NumExt for f64 {} +pub impl NumExt for float {} pub trait UnSignedExt: NumExt {} -pub impl u8: UnSignedExt {} -pub impl u16: UnSignedExt {} -pub impl u32: UnSignedExt {} -pub impl u64: UnSignedExt {} -pub impl uint: UnSignedExt {} +pub impl UnSignedExt for u8 {} +pub impl UnSignedExt for u16 {} +pub impl UnSignedExt for u32 {} +pub impl UnSignedExt for u64 {} +pub impl UnSignedExt for uint {} pub trait SignedExt: NumExt {} -pub impl i8: SignedExt {} -pub impl i16: SignedExt {} -pub impl i32: SignedExt {} -pub impl i64: SignedExt {} -pub impl int: SignedExt {} +pub impl SignedExt for i8 {} +pub impl SignedExt for i16 {} +pub impl SignedExt for i32 {} +pub impl SignedExt for i64 {} +pub impl SignedExt for int {} -pub impl f32: SignedExt {} -pub impl f64: SignedExt {} -pub impl float: SignedExt {} +pub impl SignedExt for f32 {} +pub impl SignedExt for f64 {} +pub impl SignedExt for float {} pub trait IntegerExt: NumExt {} -pub impl u8: IntegerExt {} -pub impl u16: IntegerExt {} -pub impl u32: IntegerExt {} -pub impl u64: IntegerExt {} -pub impl uint: IntegerExt {} +pub impl IntegerExt for u8 {} +pub impl IntegerExt for u16 {} +pub impl IntegerExt for u32 {} +pub impl IntegerExt for u64 {} +pub impl IntegerExt for uint {} -pub impl i8: IntegerExt {} -pub impl i16: IntegerExt {} -pub impl i32: IntegerExt {} -pub impl i64: IntegerExt {} -pub impl int: IntegerExt {} +pub impl IntegerExt for i8 {} +pub impl IntegerExt for i16 {} +pub impl IntegerExt for i32 {} +pub impl IntegerExt for i64 {} +pub impl IntegerExt for int {} pub trait FloatExt: NumExt FuzzyEq {} -pub impl f32: FloatExt {} -pub impl f64: FloatExt {} -pub impl float: FloatExt {} +pub impl FloatExt for f32 {} +pub impl FloatExt for f64 {} +pub impl FloatExt for float {} fn test_float_ext(n: T) { io::println(fmt!("%?", n < n)) } diff --git a/src/test/run-pass/trait-inheritance-num3.rs b/src/test/run-pass/trait-inheritance-num3.rs index 30cc5423022..f184ab2741a 100644 --- a/src/test/run-pass/trait-inheritance-num3.rs +++ b/src/test/run-pass/trait-inheritance-num3.rs @@ -13,7 +13,7 @@ use num::NumCast::from; pub trait NumExt: Eq Ord NumCast {} -pub impl f32: NumExt {} +pub impl NumExt for f32 {} fn num_eq_one(n: T) { io::println(fmt!("%?", n == from(1))) } diff --git a/src/test/run-pass/trait-inheritance-num5.rs b/src/test/run-pass/trait-inheritance-num5.rs index c2b88c59f87..692d50e541a 100644 --- a/src/test/run-pass/trait-inheritance-num5.rs +++ b/src/test/run-pass/trait-inheritance-num5.rs @@ -13,8 +13,8 @@ use num::NumCast::from; pub trait NumExt: Eq NumCast {} -pub impl f32: NumExt {} -pub impl int: NumExt {} +pub impl NumExt for f32 {} +pub impl NumExt for int {} fn num_eq_one() -> T { from(1) diff --git a/src/test/run-pass/trait-inheritance-overloading-simple.rs b/src/test/run-pass/trait-inheritance-overloading-simple.rs index c41579e3603..b068d109ccf 100644 --- a/src/test/run-pass/trait-inheritance-overloading-simple.rs +++ b/src/test/run-pass/trait-inheritance-overloading-simple.rs @@ -19,7 +19,7 @@ impl Eq for MyInt { pure fn ne(&self, other: &MyInt) -> bool { !self.eq(other) } } -impl MyInt : MyNum; +impl MyNum for MyInt; fn f(x: T, y: T) -> bool { return x == y; diff --git a/src/test/run-pass/trait-inheritance-overloading.rs b/src/test/run-pass/trait-inheritance-overloading.rs index 56cdb5d3118..f56a950f918 100644 --- a/src/test/run-pass/trait-inheritance-overloading.rs +++ b/src/test/run-pass/trait-inheritance-overloading.rs @@ -31,7 +31,7 @@ impl Eq for MyInt { pure fn ne(&self, other: &MyInt) -> bool { !self.eq(other) } } -impl MyInt : MyNum; +impl MyNum for MyInt; fn f(x: T, y: T) -> (T, T, T) { return (x + y, x - y, x * y); diff --git a/src/test/run-pass/trait-inheritance-subst.rs b/src/test/run-pass/trait-inheritance-subst.rs index 03b7e37a7ad..ea3e75f3551 100644 --- a/src/test/run-pass/trait-inheritance-subst.rs +++ b/src/test/run-pass/trait-inheritance-subst.rs @@ -20,7 +20,7 @@ impl Add for MyInt { pure fn add(other: &MyInt) -> MyInt { mi(self.val + other.val) } } -impl MyInt : MyNum; +impl MyNum for MyInt; fn f(x: T, y: T) -> T { return x.add(&y); diff --git a/src/test/run-pass/trait-inheritance-subst2.rs b/src/test/run-pass/trait-inheritance-subst2.rs index 378c78cfd92..ab755da7099 100644 --- a/src/test/run-pass/trait-inheritance-subst2.rs +++ b/src/test/run-pass/trait-inheritance-subst2.rs @@ -30,7 +30,7 @@ impl Add for MyInt { fn add(other: &MyInt) -> MyInt { self.chomp(other) } } -impl MyInt : MyNum; +impl MyNum for MyInt; fn f(x: T, y: T) -> T { return x.add(&y).chomp(&y); diff --git a/src/test/run-pass/trait-inheritance2.rs b/src/test/run-pass/trait-inheritance2.rs index 3dee07194dd..08448a65ac8 100644 --- a/src/test/run-pass/trait-inheritance2.rs +++ b/src/test/run-pass/trait-inheritance2.rs @@ -19,7 +19,7 @@ struct A { x: int } impl Foo for A { fn f() -> int { 10 } } impl Bar for A { fn g() -> int { 20 } } impl Baz for A { fn h() -> int { 30 } } -impl A : Quux; +impl Quux for A; fn f(a: &T) { assert a.f() == 10; diff --git a/src/test/run-pass/trait-static-method-overwriting.rs b/src/test/run-pass/trait-static-method-overwriting.rs index 9538ea497ec..d416f3f6c91 100644 --- a/src/test/run-pass/trait-static-method-overwriting.rs +++ b/src/test/run-pass/trait-static-method-overwriting.rs @@ -19,7 +19,7 @@ mod base { dummy: (), } - pub impl Foo : ::base::HasNew { + pub impl ::base::HasNew for Foo { static pure fn new() -> Foo { unsafe { io::println("Foo"); } Foo { dummy: () } @@ -30,7 +30,7 @@ mod base { dummy: (), } - pub impl Bar : ::base::HasNew { + pub impl ::base::HasNew for Bar { static pure fn new() -> Bar { unsafe { io::println("Bar"); } Bar { dummy: () }