Add #[inline(always)] to each operator method

brendanzab · brendanzab · commit 939a97f5cb4c · 2013-04-18T23:24:24.000+10:00
diff --git a/src/libcore/num/f32.rs b/src/libcore/num/f32.rs
@@ -288,26 +288,32 @@ impl num::One for f32 {
 
 #[cfg(notest)]
 impl ops::Add<f32,f32> for f32 {
+    #[inline(always)]
     fn add(&self, other: &f32) -> f32 { *self + *other }
 }
 #[cfg(notest)]
 impl ops::Sub<f32,f32> for f32 {
+    #[inline(always)]
     fn sub(&self, other: &f32) -> f32 { *self - *other }
 }
 #[cfg(notest)]
 impl ops::Mul<f32,f32> for f32 {
+    #[inline(always)]
     fn mul(&self, other: &f32) -> f32 { *self * *other }
 }
 #[cfg(notest)]
 impl ops::Div<f32,f32> for f32 {
+    #[inline(always)]
     fn div(&self, other: &f32) -> f32 { *self / *other }
 }
 #[cfg(notest)]
 impl ops::Modulo<f32,f32> for f32 {
+    #[inline(always)]
     fn modulo(&self, other: &f32) -> f32 { *self % *other }
 }
 #[cfg(notest)]
 impl ops::Neg<f32> for f32 {
+    #[inline(always)]
     fn neg(&self) -> f32 { -*self }
 }
 
diff --git a/src/libcore/num/f64.rs b/src/libcore/num/f64.rs
@@ -310,26 +310,32 @@ impl num::One for f64 {
 
 #[cfg(notest)]
 impl ops::Add<f64,f64> for f64 {
+    #[inline(always)]
     fn add(&self, other: &f64) -> f64 { *self + *other }
 }
 #[cfg(notest)]
 impl ops::Sub<f64,f64> for f64 {
+    #[inline(always)]
     fn sub(&self, other: &f64) -> f64 { *self - *other }
 }
 #[cfg(notest)]
 impl ops::Mul<f64,f64> for f64 {
+    #[inline(always)]
     fn mul(&self, other: &f64) -> f64 { *self * *other }
 }
 #[cfg(notest)]
 impl ops::Div<f64,f64> for f64 {
+    #[inline(always)]
     fn div(&self, other: &f64) -> f64 { *self / *other }
 }
 #[cfg(notest)]
 impl ops::Modulo<f64,f64> for f64 {
+    #[inline(always)]
     fn modulo(&self, other: &f64) -> f64 { *self % *other }
 }
 #[cfg(notest)]
 impl ops::Neg<f64> for f64 {
+    #[inline(always)]
     fn neg(&self) -> f64 { -*self }
 }
 
diff --git a/src/libcore/num/float.rs b/src/libcore/num/float.rs
@@ -387,15 +387,21 @@ pub fn tan(x: float) -> float {
 
 #[cfg(notest)]
 impl Eq for float {
+    #[inline(always)]
     fn eq(&self, other: &float) -> bool { (*self) == (*other) }
+    #[inline(always)]
     fn ne(&self, other: &float) -> bool { (*self) != (*other) }
 }
 
 #[cfg(notest)]
 impl Ord for float {
+    #[inline(always)]
     fn lt(&self, other: &float) -> bool { (*self) < (*other) }
+    #[inline(always)]
     fn le(&self, other: &float) -> bool { (*self) <= (*other) }
+    #[inline(always)]
     fn ge(&self, other: &float) -> bool { (*self) >= (*other) }
+    #[inline(always)]
     fn gt(&self, other: &float) -> bool { (*self) > (*other) }
 }
 
@@ -444,26 +450,32 @@ impl num::Round for float {
 
 #[cfg(notest)]
 impl ops::Add<float,float> for float {
+    #[inline(always)]
     fn add(&self, other: &float) -> float { *self + *other }
 }
 #[cfg(notest)]
 impl ops::Sub<float,float> for float {
+    #[inline(always)]
     fn sub(&self, other: &float) -> float { *self - *other }
 }
 #[cfg(notest)]
 impl ops::Mul<float,float> for float {
+    #[inline(always)]
     fn mul(&self, other: &float) -> float { *self * *other }
 }
 #[cfg(notest)]
 impl ops::Div<float,float> for float {
+    #[inline(always)]
     fn div(&self, other: &float) -> float { *self / *other }
 }
 #[cfg(notest)]
 impl ops::Modulo<float,float> for float {
+    #[inline(always)]
     fn modulo(&self, other: &float) -> float { *self % *other }
 }
 #[cfg(notest)]
 impl ops::Neg<float> for float {
+    #[inline(always)]
     fn neg(&self) -> float { -*self }
 }
 
diff --git a/src/libcore/num/int-template.rs b/src/libcore/num/int-template.rs
@@ -177,50 +177,63 @@ impl num::One for T {
 
 #[cfg(notest)]
 impl ops::Add<T,T> for T {
+    #[inline(always)]
     fn add(&self, other: &T) -> T { *self + *other }
 }
 #[cfg(notest)]
 impl ops::Sub<T,T> for T {
+    #[inline(always)]
     fn sub(&self, other: &T) -> T { *self - *other }
 }
 #[cfg(notest)]
 impl ops::Mul<T,T> for T {
+    #[inline(always)]
     fn mul(&self, other: &T) -> T { *self * *other }
 }
 #[cfg(notest)]
 impl ops::Div<T,T> for T {
+    #[inline(always)]
     fn div(&self, other: &T) -> T { *self / *other }
 }
 #[cfg(notest)]
 impl ops::Modulo<T,T> for T {
+    #[inline(always)]
     fn modulo(&self, other: &T) -> T { *self % *other }
 }
 #[cfg(notest)]
 impl ops::Neg<T> for T {
+    #[inline(always)]
     fn neg(&self) -> T { -*self }
 }
+
 #[cfg(notest)]
 impl ops::BitOr<T,T> for T {
+    #[inline(always)]
     fn bitor(&self, other: &T) -> T { *self | *other }
 }
 #[cfg(notest)]
 impl ops::BitAnd<T,T> for T {
+    #[inline(always)]
     fn bitand(&self, other: &T) -> T { *self & *other }
 }
 #[cfg(notest)]
 impl ops::BitXor<T,T> for T {
+    #[inline(always)]
     fn bitxor(&self, other: &T) -> T { *self ^ *other }
 }
 #[cfg(notest)]
 impl ops::Shl<T,T> for T {
+    #[inline(always)]
     fn shl(&self, other: &T) -> T { *self << *other }
 }
 #[cfg(notest)]
 impl ops::Shr<T,T> for T {
+    #[inline(always)]
     fn shr(&self, other: &T) -> T { *self >> *other }
 }
 #[cfg(notest)]
 impl ops::Not<T> for T {
+    #[inline(always)]
     fn not(&self) -> T { !*self }
 }
 
diff --git a/src/libcore/num/uint-template.rs b/src/libcore/num/uint-template.rs
@@ -142,50 +142,63 @@ impl num::One for T {
 
 #[cfg(notest)]
 impl ops::Add<T,T> for T {
+    #[inline(always)]
     fn add(&self, other: &T) -> T { *self + *other }
 }
 #[cfg(notest)]
 impl ops::Sub<T,T> for T {
+    #[inline(always)]
     fn sub(&self, other: &T) -> T { *self - *other }
 }
 #[cfg(notest)]
 impl ops::Mul<T,T> for T {
+    #[inline(always)]
     fn mul(&self, other: &T) -> T { *self * *other }
 }
 #[cfg(notest)]
 impl ops::Div<T,T> for T {
+    #[inline(always)]
     fn div(&self, other: &T) -> T { *self / *other }
 }
 #[cfg(notest)]
 impl ops::Modulo<T,T> for T {
+    #[inline(always)]
     fn modulo(&self, other: &T) -> T { *self % *other }
 }
 #[cfg(notest)]
 impl ops::Neg<T> for T {
+    #[inline(always)]
     fn neg(&self) -> T { -*self }
 }
+
 #[cfg(notest)]
 impl ops::BitOr<T,T> for T {
+    #[inline(always)]
     fn bitor(&self, other: &T) -> T { *self | *other }
 }
 #[cfg(notest)]
 impl ops::BitAnd<T,T> for T {
+    #[inline(always)]
     fn bitand(&self, other: &T) -> T { *self & *other }
 }
 #[cfg(notest)]
 impl ops::BitXor<T,T> for T {
+    #[inline(always)]
     fn bitxor(&self, other: &T) -> T { *self ^ *other }
 }
 #[cfg(notest)]
 impl ops::Shl<T,T> for T {
+    #[inline(always)]
     fn shl(&self, other: &T) -> T { *self << *other }
 }
 #[cfg(notest)]
 impl ops::Shr<T,T> for T {
+    #[inline(always)]
     fn shr(&self, other: &T) -> T { *self >> *other }
 }
 #[cfg(notest)]
 impl ops::Not<T> for T {
+    #[inline(always)]
     fn not(&self) -> T { !*self }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -288,26 +288,32 @@ impl num::One for f32 {`
`288`	`288`
`289`	`289`	`#[cfg(notest)]`
`290`	`290`	`impl ops::Add<f32,f32> for f32 {`
	`291`	`+ #[inline(always)]`
`291`	`292`	`fn add(&self, other: &f32) -> f32 { self + other }`
`292`	`293`	`}`
`293`	`294`	`#[cfg(notest)]`
`294`	`295`	`impl ops::Sub<f32,f32> for f32 {`
	`296`	`+ #[inline(always)]`
`295`	`297`	`fn sub(&self, other: &f32) -> f32 { self - other }`
`296`	`298`	`}`
`297`	`299`	`#[cfg(notest)]`
`298`	`300`	`impl ops::Mul<f32,f32> for f32 {`
	`301`	`+ #[inline(always)]`
`299`	`302`	`fn mul(&self, other: &f32) -> f32 { self *other }`
`300`	`303`	`}`
`301`	`304`	`#[cfg(notest)]`
`302`	`305`	`impl ops::Div<f32,f32> for f32 {`
	`306`	`+ #[inline(always)]`
`303`	`307`	`fn div(&self, other: &f32) -> f32 { self / other }`
`304`	`308`	`}`
`305`	`309`	`#[cfg(notest)]`
`306`	`310`	`impl ops::Modulo<f32,f32> for f32 {`
	`311`	`+ #[inline(always)]`
`307`	`312`	`fn modulo(&self, other: &f32) -> f32 { self % other }`
`308`	`313`	`}`
`309`	`314`	`#[cfg(notest)]`
`310`	`315`	`impl ops::Neg<f32> for f32 {`
	`316`	`+ #[inline(always)]`
`311`	`317`	`fn neg(&self) -> f32 { -*self }`
`312`	`318`	`}`
`313`	`319`
Original file line number	Diff line number	Diff line change
`@@ -310,26 +310,32 @@ impl num::One for f64 {`
`310`	`310`
`311`	`311`	`#[cfg(notest)]`
`312`	`312`	`impl ops::Add<f64,f64> for f64 {`
	`313`	`+ #[inline(always)]`
`313`	`314`	`fn add(&self, other: &f64) -> f64 { self + other }`
`314`	`315`	`}`
`315`	`316`	`#[cfg(notest)]`
`316`	`317`	`impl ops::Sub<f64,f64> for f64 {`
	`318`	`+ #[inline(always)]`
`317`	`319`	`fn sub(&self, other: &f64) -> f64 { self - other }`
`318`	`320`	`}`
`319`	`321`	`#[cfg(notest)]`
`320`	`322`	`impl ops::Mul<f64,f64> for f64 {`
	`323`	`+ #[inline(always)]`
`321`	`324`	`fn mul(&self, other: &f64) -> f64 { self *other }`
`322`	`325`	`}`
`323`	`326`	`#[cfg(notest)]`
`324`	`327`	`impl ops::Div<f64,f64> for f64 {`
	`328`	`+ #[inline(always)]`
`325`	`329`	`fn div(&self, other: &f64) -> f64 { self / other }`
`326`	`330`	`}`
`327`	`331`	`#[cfg(notest)]`
`328`	`332`	`impl ops::Modulo<f64,f64> for f64 {`
	`333`	`+ #[inline(always)]`
`329`	`334`	`fn modulo(&self, other: &f64) -> f64 { self % other }`
`330`	`335`	`}`
`331`	`336`	`#[cfg(notest)]`
`332`	`337`	`impl ops::Neg<f64> for f64 {`
	`338`	`+ #[inline(always)]`
`333`	`339`	`fn neg(&self) -> f64 { -*self }`
`334`	`340`	`}`
`335`	`341`
Original file line number	Diff line number	Diff line change
`@@ -177,50 +177,63 @@ impl num::One for T {`
`177`	`177`
`178`	`178`	`#[cfg(notest)]`
`179`	`179`	`impl ops::Add<T,T> for T {`
	`180`	`+ #[inline(always)]`
`180`	`181`	`fn add(&self, other: &T) -> T { self + other }`
`181`	`182`	`}`
`182`	`183`	`#[cfg(notest)]`
`183`	`184`	`impl ops::Sub<T,T> for T {`
	`185`	`+ #[inline(always)]`
`184`	`186`	`fn sub(&self, other: &T) -> T { self - other }`
`185`	`187`	`}`
`186`	`188`	`#[cfg(notest)]`
`187`	`189`	`impl ops::Mul<T,T> for T {`
	`190`	`+ #[inline(always)]`
`188`	`191`	`fn mul(&self, other: &T) -> T { self *other }`
`189`	`192`	`}`
`190`	`193`	`#[cfg(notest)]`
`191`	`194`	`impl ops::Div<T,T> for T {`
	`195`	`+ #[inline(always)]`
`192`	`196`	`fn div(&self, other: &T) -> T { self / other }`
`193`	`197`	`}`
`194`	`198`	`#[cfg(notest)]`
`195`	`199`	`impl ops::Modulo<T,T> for T {`
	`200`	`+ #[inline(always)]`
`196`	`201`	`fn modulo(&self, other: &T) -> T { self % other }`
`197`	`202`	`}`
`198`	`203`	`#[cfg(notest)]`
`199`	`204`	`impl ops::Neg<T> for T {`
	`205`	`+ #[inline(always)]`
`200`	`206`	`fn neg(&self) -> T { -*self }`
`201`	`207`	`}`
	`208`	`+`
`202`	`209`	`#[cfg(notest)]`
`203`	`210`	`impl ops::BitOr<T,T> for T {`
	`211`	`+ #[inline(always)]`
`204`	`212`	`fn bitor(&self, other: &T) -> T { self \| other }`
`205`	`213`	`}`
`206`	`214`	`#[cfg(notest)]`
`207`	`215`	`impl ops::BitAnd<T,T> for T {`
	`216`	`+ #[inline(always)]`
`208`	`217`	`fn bitand(&self, other: &T) -> T { self & other }`
`209`	`218`	`}`
`210`	`219`	`#[cfg(notest)]`
`211`	`220`	`impl ops::BitXor<T,T> for T {`
	`221`	`+ #[inline(always)]`
`212`	`222`	`fn bitxor(&self, other: &T) -> T { self ^ other }`
`213`	`223`	`}`
`214`	`224`	`#[cfg(notest)]`
`215`	`225`	`impl ops::Shl<T,T> for T {`
	`226`	`+ #[inline(always)]`
`216`	`227`	`fn shl(&self, other: &T) -> T { self << other }`
`217`	`228`	`}`
`218`	`229`	`#[cfg(notest)]`
`219`	`230`	`impl ops::Shr<T,T> for T {`
	`231`	`+ #[inline(always)]`
`220`	`232`	`fn shr(&self, other: &T) -> T { self >> other }`
`221`	`233`	`}`
`222`	`234`	`#[cfg(notest)]`
`223`	`235`	`impl ops::Not<T> for T {`
	`236`	`+ #[inline(always)]`
`224`	`237`	`fn not(&self) -> T { !*self }`
`225`	`238`	`}`
`226`	`239`
Original file line number	Diff line number	Diff line change
`@@ -142,50 +142,63 @@ impl num::One for T {`
`142`	`142`
`143`	`143`	`#[cfg(notest)]`
`144`	`144`	`impl ops::Add<T,T> for T {`
	`145`	`+ #[inline(always)]`
`145`	`146`	`fn add(&self, other: &T) -> T { self + other }`
`146`	`147`	`}`
`147`	`148`	`#[cfg(notest)]`
`148`	`149`	`impl ops::Sub<T,T> for T {`
	`150`	`+ #[inline(always)]`
`149`	`151`	`fn sub(&self, other: &T) -> T { self - other }`
`150`	`152`	`}`
`151`	`153`	`#[cfg(notest)]`
`152`	`154`	`impl ops::Mul<T,T> for T {`
	`155`	`+ #[inline(always)]`
`153`	`156`	`fn mul(&self, other: &T) -> T { self *other }`
`154`	`157`	`}`
`155`	`158`	`#[cfg(notest)]`
`156`	`159`	`impl ops::Div<T,T> for T {`
	`160`	`+ #[inline(always)]`
`157`	`161`	`fn div(&self, other: &T) -> T { self / other }`
`158`	`162`	`}`
`159`	`163`	`#[cfg(notest)]`
`160`	`164`	`impl ops::Modulo<T,T> for T {`
	`165`	`+ #[inline(always)]`
`161`	`166`	`fn modulo(&self, other: &T) -> T { self % other }`
`162`	`167`	`}`
`163`	`168`	`#[cfg(notest)]`
`164`	`169`	`impl ops::Neg<T> for T {`
	`170`	`+ #[inline(always)]`
`165`	`171`	`fn neg(&self) -> T { -*self }`
`166`	`172`	`}`
	`173`	`+`
`167`	`174`	`#[cfg(notest)]`
`168`	`175`	`impl ops::BitOr<T,T> for T {`
	`176`	`+ #[inline(always)]`
`169`	`177`	`fn bitor(&self, other: &T) -> T { self \| other }`
`170`	`178`	`}`
`171`	`179`	`#[cfg(notest)]`
`172`	`180`	`impl ops::BitAnd<T,T> for T {`
	`181`	`+ #[inline(always)]`
`173`	`182`	`fn bitand(&self, other: &T) -> T { self & other }`
`174`	`183`	`}`
`175`	`184`	`#[cfg(notest)]`
`176`	`185`	`impl ops::BitXor<T,T> for T {`
	`186`	`+ #[inline(always)]`
`177`	`187`	`fn bitxor(&self, other: &T) -> T { self ^ other }`
`178`	`188`	`}`
`179`	`189`	`#[cfg(notest)]`
`180`	`190`	`impl ops::Shl<T,T> for T {`
	`191`	`+ #[inline(always)]`
`181`	`192`	`fn shl(&self, other: &T) -> T { self << other }`
`182`	`193`	`}`
`183`	`194`	`#[cfg(notest)]`
`184`	`195`	`impl ops::Shr<T,T> for T {`
	`196`	`+ #[inline(always)]`
`185`	`197`	`fn shr(&self, other: &T) -> T { self >> other }`
`186`	`198`	`}`
`187`	`199`	`#[cfg(notest)]`
`188`	`200`	`impl ops::Not<T> for T {`
	`201`	`+ #[inline(always)]`
`189`	`202`	`fn not(&self) -> T { !*self }`
`190`	`203`	`}`
`191`	`204`