Provide ref-transparent ops for TextSize

[CAD97]

Counter-proposal to #7. Basically the same set of impls, but set up slightly differently.

[matklad]

Do you know the reason why stdlib doesn't do this and spells all impls manually?

[CAD97]

Relevant snippets from std:

https://github.com/rust-lang/rust/blob/master/src/libcore/internal_macros.rs, https://github.com/rust-lang/rust/blob/303d8aff6092709edd4dbd35b1c88e9aa40bf6d8/src/libcore/ops/arith.rs#L101

// implements binary operators "&T op U", "T op &U", "&T op &U"
// based on "T op U" where T and U are expected to be `Copy`able
macro_rules! forward_ref_binop {
    (impl $imp:ident, $method:ident for $t:ty, $u:ty) => {
        forward_ref_binop!(impl $imp, $method for $t, $u,
                #[stable(feature = "rust1", since = "1.0.0")]);
    };
    (impl $imp:ident, $method:ident for $t:ty, $u:ty, #[$attr:meta]) => {
        #[$attr]
        impl<'a> $imp<$u> for &'a $t {
            type Output = <$t as $imp<$u>>::Output;

            #[inline]
            fn $method(self, other: $u) -> <$t as $imp<$u>>::Output {
                $imp::$method(*self, other)
            }
        }

        #[$attr]
        impl $imp<&$u> for $t {
            type Output = <$t as $imp<$u>>::Output;

            #[inline]
            fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
                $imp::$method(self, *other)
            }
        }

        #[$attr]
        impl $imp<&$u> for &$t {
            type Output = <$t as $imp<$u>>::Output;

            #[inline]
            fn $method(self, other: &$u) -> <$t as $imp<$u>>::Output {
                $imp::$method(*self, *other)
            }
        }
    }
}

// implements "T op= &U", based on "T op= U"
// where U is expected to be `Copy`able
macro_rules! forward_ref_op_assign {
    (impl $imp:ident, $method:ident for $t:ty, $u:ty) => {
        forward_ref_op_assign!(impl $imp, $method for $t, $u,
                #[stable(feature = "op_assign_builtins_by_ref", since = "1.22.0")]);
    };
    (impl $imp:ident, $method:ident for $t:ty, $u:ty, #[$attr:meta]) => {
        #[$attr]
        impl $imp<&$u> for $t {
            #[inline]
            fn $method(&mut self, other: &$u) {
                $imp::$method(self, *other);
            }
        }
    }
}

macro_rules! add_impl {
    ($($t:ty)*) => ($(
        #[stable(feature = "rust1", since = "1.0.0")]
        impl Add for $t {
            type Output = $t;

            #[inline]
            #[rustc_inherit_overflow_checks]
            fn add(self, other: $t) -> $t { self + other }
        }

        forward_ref_binop! { impl Add, add for $t, $t }
    )*)
}

add_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }

blame tracking shows that these impls date back to rust-lang/rust#21227 at the beginning of 2015 (1.0.0-alpha.2), to re-add behavior lost when changing the ops traits to take by-move rather than by-ref. At least if I'm reading history correctly.

The main reason std might not want to make the impls more generic is touchy type inference. I'm going to open an irlo thread about it.

The key thing for acting like std is not in exactly matching the std impls, though, but covering all of the std impls. I think the generic impls are better for us than just mirroring std's macro copied impls.

[CAD97]

irlo thread: https://internals.rust-lang.org/t/why-not-generalize-primitive-ops-impls/11966

[matklad]

I think it might make sense to optimistically merge this before irlo discussion is resolved. r=me after rebase

[CAD97]

bors: r=matklad

[bors]

Build succeeded

• continuous-integration/travis-ci/push