Auto merge of rust-lang#67917 - Dylan-DPC:rollup-id05y91, r=Dylan-DPC

bors · bors · commit a80e63f3fa77 · 2020-01-06T09:31:27.000Z
Rollup of 6 pull requests Successful merges: - rust-lang#67800 (Fix ICE involving calling `Instance.ty` during const evaluation) - rust-lang#67873 (change remove to have a PartialEq bound) - rust-lang#67897 (Use `as_deref()` to replace `as_ref().map(...)`) - rust-lang#67906 (Silence `TooGeneric` error) - rust-lang#67912 (macros: typo fix) - rust-lang#67915 (Use Self instead of $type) Failed merges: r? @ghost
diff --git a/src/liballoc/tests/lib.rs b/src/liballoc/tests/lib.rs
@@ -11,6 +11,7 @@
 #![feature(associated_type_bounds)]
 #![feature(binary_heap_into_iter_sorted)]
 #![feature(binary_heap_drain_sorted)]
+#![feature(vec_remove_item)]
 
 use std::collections::hash_map::DefaultHasher;
 use std::hash::{Hash, Hasher};
diff --git a/src/liballoc/tests/vec.rs b/src/liballoc/tests/vec.rs
@@ -131,6 +131,21 @@ fn test_extend_ref() {
     assert_eq!(v, [1, 2, 3, 4, 5, 6, 7]);
 }
 
+#[test]
+fn test_remove_item() {
+    let mut v = vec![1, 2, 3];
+    v.remove_item(&1);
+
+    assert_eq!(v.len(), 2);
+    assert_eq!(v, [2, 3]);
+
+    let mut w = vec![1, 2, 3];
+    w.remove_item(&4);
+
+    assert_eq!(w.len(), 3);
+    w.remove_item(&4);
+}
+
 #[test]
 fn test_slice_from_mut() {
     let mut values = vec![1, 2, 3, 4, 5];
diff --git a/src/liballoc/vec.rs b/src/liballoc/vec.rs
@@ -1688,7 +1688,9 @@ impl<T: PartialEq> Vec<T> {
     pub fn dedup(&mut self) {
         self.dedup_by(|a, b| a == b)
     }
+}
 
+impl<T> Vec<T> {
     /// Removes the first instance of `item` from the vector if the item exists.
     ///
     /// # Examples
@@ -1702,7 +1704,10 @@ impl<T: PartialEq> Vec<T> {
     /// assert_eq!(vec, vec![2, 3, 1]);
     /// ```
     #[unstable(feature = "vec_remove_item", reason = "recently added", issue = "40062")]
-    pub fn remove_item(&mut self, item: &T) -> Option<T> {
+    pub fn remove_item<V>(&mut self, item: &V) -> Option<T>
+    where
+        T: PartialEq<V>,
+    {
         let pos = self.iter().position(|x| *x == *item)?;
         Some(self.remove(pos))
     }
diff --git a/src/libcore/convert/num.rs b/src/libcore/convert/num.rs
@@ -47,8 +47,8 @@ macro_rules! impl_from {
         #[doc = $doc]
         impl From<$Small> for $Large {
             #[inline]
-            fn from(small: $Small) -> $Large {
-                small as $Large
+            fn from(small: $Small) -> Self {
+                small as Self
             }
         }
     };
@@ -177,7 +177,7 @@ macro_rules! try_from_unbounded {
             /// is outside of the range of the target type.
             #[inline]
             fn try_from(value: $source) -> Result<Self, Self::Error> {
-                Ok(value as $target)
+                Ok(value as Self)
             }
         }
     )*}
@@ -194,9 +194,9 @@ macro_rules! try_from_lower_bounded {
             /// number type. This returns an error if the source value
             /// is outside of the range of the target type.
             #[inline]
-            fn try_from(u: $source) -> Result<$target, TryFromIntError> {
+            fn try_from(u: $source) -> Result<Self, Self::Error> {
                 if u >= 0 {
-                    Ok(u as $target)
+                    Ok(u as Self)
                 } else {
                     Err(TryFromIntError(()))
                 }
@@ -216,11 +216,11 @@ macro_rules! try_from_upper_bounded {
             /// number type. This returns an error if the source value
             /// is outside of the range of the target type.
             #[inline]
-            fn try_from(u: $source) -> Result<$target, TryFromIntError> {
-                if u > (<$target>::max_value() as $source) {
+            fn try_from(u: $source) -> Result<Self, Self::Error> {
+                if u > (Self::max_value() as $source) {
                     Err(TryFromIntError(()))
                 } else {
-                    Ok(u as $target)
+                    Ok(u as Self)
                 }
             }
         }
@@ -238,13 +238,13 @@ macro_rules! try_from_both_bounded {
             /// number type. This returns an error if the source value
             /// is outside of the range of the target type.
             #[inline]
-            fn try_from(u: $source) -> Result<$target, TryFromIntError> {
-                let min = <$target>::min_value() as $source;
-                let max = <$target>::max_value() as $source;
+            fn try_from(u: $source) -> Result<Self, Self::Error> {
+                let min = Self::min_value() as $source;
+                let max = Self::max_value() as $source;
                 if u < min || u > max {
                     Err(TryFromIntError(()))
                 } else {
-                    Ok(u as $target)
+                    Ok(u as Self)
                 }
             }
         }
@@ -385,10 +385,10 @@ macro_rules! nzint_impl_from {
         #[doc = $doc]
         impl From<$Small> for $Large {
             #[inline]
-            fn from(small: $Small) -> $Large {
+            fn from(small: $Small) -> Self {
                 // SAFETY: input type guarantees the value is non-zero
                 unsafe {
-                    <$Large>::new_unchecked(small.get().into())
+                    Self::new_unchecked(small.get().into())
                 }
             }
         }
diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs
@@ -24,8 +24,8 @@ trait Int:
 
 macro_rules! doit {
     ($($t:ident)*) => ($(impl Int for $t {
-        fn zero() -> $t { 0 }
-        fn from_u8(u: u8) -> $t { u as $t }
+        fn zero() -> Self { 0 }
+        fn from_u8(u: u8) -> Self { u as Self }
         fn to_u8(&self) -> u8 { *self as u8 }
         fn to_u16(&self) -> u16 { *self as u16 }
         fn to_u32(&self) -> u32 { *self as u32 }
diff --git a/src/libcore/iter/traits/accum.rs b/src/libcore/iter/traits/accum.rs
@@ -44,28 +44,28 @@ macro_rules! integer_sum_product {
     (@impls $zero:expr, $one:expr, #[$attr:meta], $($a:ty)*) => ($(
         #[$attr]
         impl Sum for $a {
-            fn sum<I: Iterator<Item=$a>>(iter: I) -> $a {
+            fn sum<I: Iterator<Item=Self>>(iter: I) -> Self {
                 iter.fold($zero, Add::add)
             }
         }
 
         #[$attr]
         impl Product for $a {
-            fn product<I: Iterator<Item=$a>>(iter: I) -> $a {
+            fn product<I: Iterator<Item=Self>>(iter: I) -> Self {
                 iter.fold($one, Mul::mul)
             }
         }
 
         #[$attr]
         impl<'a> Sum<&'a $a> for $a {
-            fn sum<I: Iterator<Item=&'a $a>>(iter: I) -> $a {
+            fn sum<I: Iterator<Item=&'a Self>>(iter: I) -> Self {
                 iter.fold($zero, Add::add)
             }
         }
 
         #[$attr]
         impl<'a> Product<&'a $a> for $a {
-            fn product<I: Iterator<Item=&'a $a>>(iter: I) -> $a {
+            fn product<I: Iterator<Item=&'a Self>>(iter: I) -> Self {
                 iter.fold($one, Mul::mul)
             }
         }
@@ -84,28 +84,28 @@ macro_rules! float_sum_product {
     ($($a:ident)*) => ($(
         #[stable(feature = "iter_arith_traits", since = "1.12.0")]
         impl Sum for $a {
-            fn sum<I: Iterator<Item=$a>>(iter: I) -> $a {
+            fn sum<I: Iterator<Item=Self>>(iter: I) -> Self {
                 iter.fold(0.0, Add::add)
             }
         }
 
         #[stable(feature = "iter_arith_traits", since = "1.12.0")]
         impl Product for $a {
-            fn product<I: Iterator<Item=$a>>(iter: I) -> $a {
+            fn product<I: Iterator<Item=Self>>(iter: I) -> Self {
                 iter.fold(1.0, Mul::mul)
             }
         }
 
         #[stable(feature = "iter_arith_traits", since = "1.12.0")]
         impl<'a> Sum<&'a $a> for $a {
-            fn sum<I: Iterator<Item=&'a $a>>(iter: I) -> $a {
+            fn sum<I: Iterator<Item=&'a Self>>(iter: I) -> Self {
                 iter.fold(0.0, Add::add)
             }
         }
 
         #[stable(feature = "iter_arith_traits", since = "1.12.0")]
         impl<'a> Product<&'a $a> for $a {
-            fn product<I: Iterator<Item=&'a $a>>(iter: I) -> $a {
+            fn product<I: Iterator<Item=&'a Self>>(iter: I) -> Self {
                 iter.fold(1.0, Mul::mul)
             }
         }
diff --git a/src/libcore/macros/mod.rs b/src/libcore/macros/mod.rs
@@ -551,7 +551,7 @@ macro_rules! unreachable {
 
 /// Indicates unimplemented code by panicking with a message of "not implemented".
 ///
-/// This allows the your code to type-check, which is useful if you are prototyping or
+/// This allows your code to type-check, which is useful if you are prototyping or
 /// implementing a trait that requires multiple methods which you don't plan of using all of.
 ///
 /// The difference between `unimplemented!` and [`todo!`](macro.todo.html) is that while `todo!`
diff --git a/src/libcore/marker.rs b/src/libcore/marker.rs
@@ -505,15 +505,15 @@ macro_rules! impls {
 
         #[stable(feature = "rust1", since = "1.0.0")]
         impl<T: ?Sized> Clone for $t<T> {
-            fn clone(&self) -> $t<T> {
-                $t
+            fn clone(&self) -> Self {
+                Self
             }
         }
 
         #[stable(feature = "rust1", since = "1.0.0")]
         impl<T: ?Sized> Default for $t<T> {
-            fn default() -> $t<T> {
-                $t
+            fn default() -> Self {
+                Self
             }
         }
 
diff --git a/src/libcore/num/bignum.rs b/src/libcore/num/bignum.rs
@@ -455,8 +455,8 @@ macro_rules! define_bignum {
         }
 
         impl crate::clone::Clone for $name {
-            fn clone(&self) -> $name {
-                $name { size: self.size, base: self.base }
+            fn clone(&self) -> Self {
+                Self { size: self.size, base: self.base }
             }
         }
 
diff --git a/src/librustc/traits/error_reporting.rs b/src/librustc/traits/error_reporting.rs
@@ -12,6 +12,7 @@ use crate::hir::Node;
 use crate::infer::error_reporting::TypeAnnotationNeeded as ErrorCode;
 use crate::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
 use crate::infer::{self, InferCtxt};
+use crate::mir::interpret::ErrorHandled;
 use crate::session::DiagnosticMessageId;
 use crate::ty::error::ExpectedFound;
 use crate::ty::fast_reject;
@@ -1086,6 +1087,11 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
 
             // already reported in the query
             ConstEvalFailure(err) => {
+                if let ErrorHandled::TooGeneric = err {
+                    // Silence this error, as it can be produced during intermediate steps
+                    // when a constant is not yet able to be evaluated (but will be later).
+                    return;
+                }
                 self.tcx.sess.delay_span_bug(
                     span,
                     &format!("constant in type had an ignored error: {:?}", err),
diff --git a/src/librustc/ty/instance.rs b/src/librustc/ty/instance.rs
@@ -62,10 +62,35 @@ pub enum InstanceDef<'tcx> {
 }
 
 impl<'tcx> Instance<'tcx> {
-    pub fn ty(&self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
+    /// Returns the `Ty` corresponding to this `Instance`,
+    /// with generic substitutions applied and lifetimes erased.
+    ///
+    /// This method can only be called when the 'substs' for this Instance
+    /// are fully monomorphic (no `ty::Param`'s are present).
+    /// This is usually the case (e.g. during codegen).
+    /// However, during constant evaluation, we may want
+    /// to try to resolve a `Instance` using generic parameters
+    /// (e.g. when we are attempting to to do const-propagation).
+    /// In this case, `Instance.ty_env` should be used to provide
+    /// the `ParamEnv` for our generic context.
+    pub fn monomorphic_ty(&self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
         let ty = tcx.type_of(self.def.def_id());
+        // There shouldn't be any params - if there are, then
+        // Instance.ty_env should have been used to provide the proper
+        // ParamEnv
+        if self.substs.has_param_types() {
+            bug!("Instance.ty called for type {:?} with params in substs: {:?}", ty, self.substs);
+        }
         tcx.subst_and_normalize_erasing_regions(self.substs, ty::ParamEnv::reveal_all(), &ty)
     }
+
+    /// Like `Instance.ty`, but allows a `ParamEnv` to be specified for use during
+    /// normalization. This method is only really useful during constant evaluation,
+    /// where we are dealing with potentially generic types.
+    pub fn ty_env(&self, tcx: TyCtxt<'tcx>, param_env: ty::ParamEnv<'tcx>) -> Ty<'tcx> {
+        let ty = tcx.type_of(self.def.def_id());
+        tcx.subst_and_normalize_erasing_regions(self.substs, param_env, &ty)
+    }
 }
 
 impl<'tcx> InstanceDef<'tcx> {
diff --git a/src/librustc/ty/layout.rs b/src/librustc/ty/layout.rs
@@ -2301,7 +2301,7 @@ impl<'tcx> ty::Instance<'tcx> {
     // or should go through `FnAbi` instead, to avoid losing any
     // adjustments `FnAbi::of_instance` might be performing.
     fn fn_sig_for_fn_abi(&self, tcx: TyCtxt<'tcx>) -> ty::PolyFnSig<'tcx> {
-        let ty = self.ty(tcx);
+        let ty = self.monomorphic_ty(tcx);
         match ty.kind {
             ty::FnDef(..) |
             // Shims currently have type FnPtr. Not sure this should remain.
diff --git a/src/librustc_codegen_llvm/callee.rs b/src/librustc_codegen_llvm/callee.rs
@@ -36,7 +36,7 @@ pub fn get_fn(cx: &CodegenCx<'ll, 'tcx>, instance: Instance<'tcx>) -> &'ll Value
     }
 
     let sym = tcx.symbol_name(instance).name.as_str();
-    debug!("get_fn({:?}: {:?}) => {}", instance, instance.ty(cx.tcx()), sym);
+    debug!("get_fn({:?}: {:?}) => {}", instance, instance.monomorphic_ty(cx.tcx()), sym);
 
     let fn_abi = FnAbi::of_instance(cx, instance, &[]);
 
diff --git a/src/librustc_codegen_llvm/consts.rs b/src/librustc_codegen_llvm/consts.rs
@@ -204,7 +204,7 @@ impl CodegenCx<'ll, 'tcx> {
             def_id
         );
 
-        let ty = instance.ty(self.tcx);
+        let ty = instance.monomorphic_ty(self.tcx);
         let sym = self.tcx.symbol_name(instance).name;
 
         debug!("get_static: sym={} instance={:?}", sym, instance);
@@ -361,7 +361,7 @@ impl StaticMethods for CodegenCx<'ll, 'tcx> {
             };
 
             let instance = Instance::mono(self.tcx, def_id);
-            let ty = instance.ty(self.tcx);
+            let ty = instance.monomorphic_ty(self.tcx);
             let llty = self.layout_of(ty).llvm_type(self);
             let g = if val_llty == llty {
                 g
diff --git a/src/librustc_codegen_llvm/debuginfo/metadata.rs b/src/librustc_codegen_llvm/debuginfo/metadata.rs
@@ -2287,7 +2287,7 @@ pub fn create_global_var_metadata(cx: &CodegenCx<'ll, '_>, def_id: DefId, global
     };
 
     let is_local_to_unit = is_node_local_to_unit(cx, def_id);
-    let variable_type = Instance::mono(cx.tcx, def_id).ty(cx.tcx);
+    let variable_type = Instance::mono(cx.tcx, def_id).monomorphic_ty(cx.tcx);
     let type_metadata = type_metadata(cx, variable_type, span);
     let var_name = SmallCStr::new(&tcx.item_name(def_id).as_str());
     let linkage_name = if no_mangle {
diff --git a/src/librustc_codegen_llvm/intrinsic.rs b/src/librustc_codegen_llvm/intrinsic.rs
@@ -89,7 +89,7 @@ impl IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> {
         span: Span,
     ) {
         let tcx = self.tcx;
-        let callee_ty = instance.ty(tcx);
+        let callee_ty = instance.monomorphic_ty(tcx);
 
         let (def_id, substs) = match callee_ty.kind {
             ty::FnDef(def_id, substs) => (def_id, substs),
diff --git a/src/librustc_codegen_llvm/mono_item.rs b/src/librustc_codegen_llvm/mono_item.rs
@@ -22,7 +22,7 @@ impl PreDefineMethods<'tcx> for CodegenCx<'ll, 'tcx> {
         symbol_name: &str,
     ) {
         let instance = Instance::mono(self.tcx, def_id);
-        let ty = instance.ty(self.tcx);
+        let ty = instance.monomorphic_ty(self.tcx);
         let llty = self.layout_of(ty).llvm_type(self);
 
         let g = self.define_global(symbol_name, llty).unwrap_or_else(|| {
diff --git a/src/librustc_mir/const_eval/eval_queries.rs b/src/librustc_mir/const_eval/eval_queries.rs
@@ -221,7 +221,7 @@ pub fn const_eval_validated_provider<'tcx>(
     // We call `const_eval` for zero arg intrinsics, too, in order to cache their value.
     // Catch such calls and evaluate them instead of trying to load a constant's MIR.
     if let ty::InstanceDef::Intrinsic(def_id) = key.value.instance.def {
-        let ty = key.value.instance.ty(tcx);
+        let ty = key.value.instance.ty_env(tcx, key.param_env);
         let substs = match ty.kind {
             ty::FnDef(_, substs) => substs,
             _ => bug!("intrinsic with type {:?}", ty),
diff --git a/src/librustc_mir/interpret/terminator.rs b/src/librustc_mir/interpret/terminator.rs
@@ -204,7 +204,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         // ABI check
         {
             let callee_abi = {
-                let instance_ty = instance.ty(*self.tcx);
+                let instance_ty = instance.ty_env(*self.tcx, self.param_env);
                 match instance_ty.kind {
                     ty::FnDef(..) => instance_ty.fn_sig(*self.tcx).abi(),
                     ty::Closure(..) => Abi::RustCall,
diff --git a/src/librustc_mir/interpret/traits.rs b/src/librustc_mir/interpret/traits.rs
@@ -140,7 +140,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         // to determine the type.
         let drop_instance = self.memory.get_fn(drop_fn)?.as_instance()?;
         trace!("Found drop fn: {:?}", drop_instance);
-        let fn_sig = drop_instance.ty(*self.tcx).fn_sig(*self.tcx);
+        let fn_sig = drop_instance.ty_env(*self.tcx, self.param_env).fn_sig(*self.tcx);
         let fn_sig = self.tcx.normalize_erasing_late_bound_regions(self.param_env, &fn_sig);
         // The drop function takes `*mut T` where `T` is the type being dropped, so get that.
         let args = fn_sig.inputs();
diff --git a/src/librustc_mir/monomorphize/collector.rs b/src/librustc_mir/monomorphize/collector.rs
diff --git a/src/librustc_typeck/impl_wf_check.rs b/src/librustc_typeck/impl_wf_check.rs
diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs
diff --git a/src/test/ui/const-generics/array-size-in-generic-struct-param.rs b/src/test/ui/const-generics/array-size-in-generic-struct-param.rs
diff --git a/src/test/ui/const-generics/array-size-in-generic-struct-param.stderr b/src/test/ui/const-generics/array-size-in-generic-struct-param.stderr
diff --git a/src/test/ui/issues/issue-8460.rs b/src/test/ui/issues/issue-8460.rs
diff --git a/src/test/ui/mir/issue-67639-normalization-ice.rs b/src/test/ui/mir/issue-67639-normalization-ice.rs

Original file line number	Diff line number	Diff line change
`@@ -47,8 +47,8 @@ macro_rules! impl_from {`
`47`	`47`	`#[doc = $doc]`
`48`	`48`	`impl From<$Small> for $Large {`
`49`	`49`	`#[inline]`
`50`		`- fn from(small: $Small) -> $Large {`
`51`		`- small as $Large`
	`50`	`+ fn from(small: $Small) -> Self {`
	`51`	`+ small as Self`
`52`	`52`	`}`
`53`	`53`	`}`
`54`	`54`	`};`
`@@ -177,7 +177,7 @@ macro_rules! try_from_unbounded {`
`177`	`177`	`/// is outside of the range of the target type.`
`178`	`178`	`#[inline]`
`179`	`179`	`fn try_from(value: $source) -> Result<Self, Self::Error> {`
`180`		`- Ok(value as $target)`
	`180`	`+ Ok(value as Self)`
`181`	`181`	`}`
`182`	`182`	`}`
`183`	`183`	`)*}`
`@@ -194,9 +194,9 @@ macro_rules! try_from_lower_bounded {`
`194`	`194`	`/// number type. This returns an error if the source value`
`195`	`195`	`/// is outside of the range of the target type.`
`196`	`196`	`#[inline]`
`197`		`- fn try_from(u: $source) -> Result<$target, TryFromIntError> {`
	`197`	`+ fn try_from(u: $source) -> Result<Self, Self::Error> {`
`198`	`198`	`if u >= 0 {`
`199`		`- Ok(u as $target)`
	`199`	`+ Ok(u as Self)`
`200`	`200`	`} else {`
`201`	`201`	`Err(TryFromIntError(()))`
`202`	`202`	`}`
`@@ -216,11 +216,11 @@ macro_rules! try_from_upper_bounded {`
`216`	`216`	`/// number type. This returns an error if the source value`
`217`	`217`	`/// is outside of the range of the target type.`
`218`	`218`	`#[inline]`
`219`		`- fn try_from(u: $source) -> Result<$target, TryFromIntError> {`
`220`		`- if u > (<$target>::max_value() as $source) {`
	`219`	`+ fn try_from(u: $source) -> Result<Self, Self::Error> {`
	`220`	`+ if u > (Self::max_value() as $source) {`
`221`	`221`	`Err(TryFromIntError(()))`
`222`	`222`	`} else {`
`223`		`- Ok(u as $target)`
	`223`	`+ Ok(u as Self)`
`224`	`224`	`}`
`225`	`225`	`}`
`226`	`226`	`}`
`@@ -238,13 +238,13 @@ macro_rules! try_from_both_bounded {`
`238`	`238`	`/// number type. This returns an error if the source value`
`239`	`239`	`/// is outside of the range of the target type.`
`240`	`240`	`#[inline]`
`241`		`- fn try_from(u: $source) -> Result<$target, TryFromIntError> {`
`242`		`- let min = <$target>::min_value() as $source;`
`243`		`- let max = <$target>::max_value() as $source;`
	`241`	`+ fn try_from(u: $source) -> Result<Self, Self::Error> {`
	`242`	`+ let min = Self::min_value() as $source;`
	`243`	`+ let max = Self::max_value() as $source;`
`244`	`244`	`if u < min \|\| u > max {`
`245`	`245`	`Err(TryFromIntError(()))`
`246`	`246`	`} else {`
`247`		`- Ok(u as $target)`
	`247`	`+ Ok(u as Self)`
`248`	`248`	`}`
`249`	`249`	`}`
`250`	`250`	`}`
`@@ -385,10 +385,10 @@ macro_rules! nzint_impl_from {`
`385`	`385`	`#[doc = $doc]`
`386`	`386`	`impl From<$Small> for $Large {`
`387`	`387`	`#[inline]`
`388`		`- fn from(small: $Small) -> $Large {`
	`388`	`+ fn from(small: $Small) -> Self {`
`389`	`389`	`// SAFETY: input type guarantees the value is non-zero`
`390`	`390`	`unsafe {`
`391`		`- <$Large>::new_unchecked(small.get().into())`
	`391`	`+ Self::new_unchecked(small.get().into())`
`392`	`392`	`}`
`393`	`393`	`}`
`394`	`394`	`}`
Original file line number	Diff line number	Diff line change
`@@ -44,28 +44,28 @@ macro_rules! integer_sum_product {`
`44`	`44`	`(@impls $zero:expr, $one:expr, #[$attr:meta], $($a:ty)*) => ($(`
`45`	`45`	`#[$attr]`
`46`	`46`	`impl Sum for $a {`
`47`		`- fn sum<I: Iterator<Item=$a>>(iter: I) -> $a {`
	`47`	`+ fn sum<I: Iterator<Item=Self>>(iter: I) -> Self {`
`48`	`48`	`iter.fold($zero, Add::add)`
`49`	`49`	`}`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`#[$attr]`
`53`	`53`	`impl Product for $a {`
`54`		`- fn product<I: Iterator<Item=$a>>(iter: I) -> $a {`
	`54`	`+ fn product<I: Iterator<Item=Self>>(iter: I) -> Self {`
`55`	`55`	`iter.fold($one, Mul::mul)`
`56`	`56`	`}`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`#[$attr]`
`60`	`60`	`impl<'a> Sum<&'a $a> for $a {`
`61`		`- fn sum<I: Iterator<Item=&'a $a>>(iter: I) -> $a {`
	`61`	`+ fn sum<I: Iterator<Item=&'a Self>>(iter: I) -> Self {`
`62`	`62`	`iter.fold($zero, Add::add)`
`63`	`63`	`}`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`#[$attr]`
`67`	`67`	`impl<'a> Product<&'a $a> for $a {`
`68`		`- fn product<I: Iterator<Item=&'a $a>>(iter: I) -> $a {`
	`68`	`+ fn product<I: Iterator<Item=&'a Self>>(iter: I) -> Self {`
`69`	`69`	`iter.fold($one, Mul::mul)`
`70`	`70`	`}`
`71`	`71`	`}`
`@@ -84,28 +84,28 @@ macro_rules! float_sum_product {`
`84`	`84`	`($($a:ident)*) => ($(`
`85`	`85`	`#[stable(feature = "iter_arith_traits", since = "1.12.0")]`
`86`	`86`	`impl Sum for $a {`
`87`		`- fn sum<I: Iterator<Item=$a>>(iter: I) -> $a {`
	`87`	`+ fn sum<I: Iterator<Item=Self>>(iter: I) -> Self {`
`88`	`88`	`iter.fold(0.0, Add::add)`
`89`	`89`	`}`
`90`	`90`	`}`
`91`	`91`
`92`	`92`	`#[stable(feature = "iter_arith_traits", since = "1.12.0")]`
`93`	`93`	`impl Product for $a {`
`94`		`- fn product<I: Iterator<Item=$a>>(iter: I) -> $a {`
	`94`	`+ fn product<I: Iterator<Item=Self>>(iter: I) -> Self {`
`95`	`95`	`iter.fold(1.0, Mul::mul)`
`96`	`96`	`}`
`97`	`97`	`}`
`98`	`98`
`99`	`99`	`#[stable(feature = "iter_arith_traits", since = "1.12.0")]`
`100`	`100`	`impl<'a> Sum<&'a $a> for $a {`
`101`		`- fn sum<I: Iterator<Item=&'a $a>>(iter: I) -> $a {`
	`101`	`+ fn sum<I: Iterator<Item=&'a Self>>(iter: I) -> Self {`
`102`	`102`	`iter.fold(0.0, Add::add)`
`103`	`103`	`}`
`104`	`104`	`}`
`105`	`105`
`106`	`106`	`#[stable(feature = "iter_arith_traits", since = "1.12.0")]`
`107`	`107`	`impl<'a> Product<&'a $a> for $a {`
`108`		`- fn product<I: Iterator<Item=&'a $a>>(iter: I) -> $a {`
	`108`	`+ fn product<I: Iterator<Item=&'a Self>>(iter: I) -> Self {`
`109`	`109`	`iter.fold(1.0, Mul::mul)`
`110`	`110`	`}`
`111`	`111`	`}`
Original file line number	Diff line number	Diff line change
`@@ -505,15 +505,15 @@ macro_rules! impls {`
`505`	`505`
`506`	`506`	`#[stable(feature = "rust1", since = "1.0.0")]`
`507`	`507`	`impl<T: ?Sized> Clone for $t<T> {`
`508`		`- fn clone(&self) -> $t<T> {`
`509`		`- $t`
	`508`	`+ fn clone(&self) -> Self {`
	`509`	`+ Self`
`510`	`510`	`}`
`511`	`511`	`}`
`512`	`512`
`513`	`513`	`#[stable(feature = "rust1", since = "1.0.0")]`
`514`	`514`	`impl<T: ?Sized> Default for $t<T> {`
`515`		`- fn default() -> $t<T> {`
`516`		`- $t`
	`515`	`+ fn default() -> Self {`
	`516`	`+ Self`
`517`	`517`	`}`
`518`	`518`	`}`
`519`	`519`
Original file line number	Diff line number	Diff line change
`@@ -455,8 +455,8 @@ macro_rules! define_bignum {`
`455`	`455`	`}`
`456`	`456`
`457`	`457`	`impl crate::clone::Clone for $name {`
`458`		`- fn clone(&self) -> $name {`
`459`		`- $name { size: self.size, base: self.base }`
	`458`	`+ fn clone(&self) -> Self {`
	`459`	`+ Self { size: self.size, base: self.base }`
`460`	`460`	`}`
`461`	`461`	`}`
`462`	`462`