diff --git a/COPYRIGHT b/COPYRIGHT index 0eac7ac9de2c5..5ab70b7120fd9 100644 --- a/COPYRIGHT +++ b/COPYRIGHT @@ -6,7 +6,7 @@ terms. Longer version: -The Rust Project is copyright 2015, The Rust Project +The Rust Project is copyright 2016, The Rust Project Developers (given in the file AUTHORS.txt). Licensed under the Apache License, Version 2.0 diff --git a/LICENSE-MIT b/LICENSE-MIT index e69282e381bc0..40b8817a47beb 100644 --- a/LICENSE-MIT +++ b/LICENSE-MIT @@ -1,4 +1,4 @@ -Copyright (c) 2015 The Rust Project Developers +Copyright (c) 2016 The Rust Project Developers Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated diff --git a/README.md b/README.md index 6e5e1ca0c3282..7558065831ace 100644 --- a/README.md +++ b/README.md @@ -53,6 +53,16 @@ Read ["Installing Rust"] from [The Book]. ### Building on Windows +There are two prominent ABIs in use on Windows: the native (MSVC) ABI used by +Visual Studio, and the GNU ABI used by the GCC toolchain. Which version of Rust +you need depends largely on what C/C++ libraries you want to interoperate with: +for interop with software produced by Visual Studio use the MSVC build of Rust; +for interop with GNU software built using the MinGW/MSYS2 toolchain use the GNU +build. + + +#### MinGW + [MSYS2](http://msys2.github.io/) can be used to easily build Rust on Windows: 1. Grab the latest MSYS2 installer and go through the installer. @@ -63,12 +73,15 @@ Read ["Installing Rust"] from [The Book]. ```sh # Update package mirrors (may be needed if you have a fresh install of MSYS2) $ pacman -Sy pacman-mirrors + ``` - # Choose one based on platform: - # *** see the note below *** - $ pacman -S mingw-w64-i686-toolchain - $ pacman -S mingw-w64-x86_64-toolchain +Download [MinGW from +here](http://mingw-w64.org/doku.php/download/mingw-builds), and choose the +`threads=win32,exceptions=dwarf/seh` flavor when installing. After installing, +add its `bin` directory to your `PATH`. This is due to #28260, in the future, +installing from pacman should be just fine. + ``` # Make git available in MSYS2 (if not already available on path) $ pacman -S git @@ -84,16 +97,19 @@ Read ["Installing Rust"] from [The Book]. $ ./configure $ make && make install ``` -> ***Note:*** gcc versions >= 5 currently have issues building LLVM on Windows -> resulting in a segmentation fault when building Rust. In order to avoid this -> it may be necessary to obtain an earlier version of gcc such as 4.9.x. -> Msys's `pacman` will install the latest version, so for the time being it is -> recommended to skip gcc toolchain installation step above and use [Mingw-Builds] -> project's installer instead. Be sure to add gcc `bin` directory to the path -> before running `configure`. -> For more information on this see issue #28260. - -[Mingw-Builds]: http://sourceforge.net/projects/mingw-w64/ + +#### MSVC + +MSVC builds of Rust additionally require an installation of Visual Studio 2013 +(or later) so `rustc` can use its linker. Make sure to check the “C++ tools” +option. In addition, `cmake` needs to be installed to build LLVM. + +With these dependencies installed, the build takes two steps: + +```sh +$ ./configure +$ make && make install +``` ## Building Documentation diff --git a/src/doc/book/error-handling.md b/src/doc/book/error-handling.md index be60ea8f81fc3..e2701553be7d1 100644 --- a/src/doc/book/error-handling.md +++ b/src/doc/book/error-handling.md @@ -1573,11 +1573,11 @@ fn main() { let matches = match opts.parse(&args[1..]) { Ok(m) => { m } - Err(e) => { panic!(e.to_string()) } + Err(e) => { panic!(e.to_string()) } }; if matches.opt_present("h") { print_usage(&program, opts); - return; + return; } let data_path = args[1].clone(); let city = args[2].clone(); @@ -1795,6 +1795,10 @@ To convert this to proper error handling, we need to do the following: Let's try it: ```rust,ignore +use std::error::Error + +// The rest of the code before this is unchanged + fn search> (file_path: P, city: &str) -> Result, Box> { @@ -1903,8 +1907,13 @@ let city = if !matches.free.is_empty() { return; }; -for pop in search(&data_file, &city) { - println!("{}, {}: {:?}", pop.city, pop.country, pop.count); +match search(&data_file, &city) { + Ok(pops) => { + for pop in pops { + println!("{}, {}: {:?}", pop.city, pop.country, pop.count); + } + } + Err(err) => println!("{}", err) } ... ``` @@ -1927,6 +1936,10 @@ that it is generic on some type parameter `R` that satisfies `io::Read`. Another way is to just use trait objects: ```rust,ignore +use std::io; + +// The rest of the code before this is unchanged + fn search> (file_path: &Option

, city: &str) -> Result, Box> { diff --git a/src/doc/book/structs.md b/src/doc/book/structs.md index 1d70ee2786919..75d0093b1476a 100644 --- a/src/doc/book/structs.md +++ b/src/doc/book/structs.md @@ -88,6 +88,35 @@ fn main() { } ``` +Your structure can still contain `&mut` pointers, which will let +you do some kinds of mutation: + +```rust +struct Point { + x: i32, + y: i32, +} + +struct PointRef<'a> { + x: &'a mut i32, + y: &'a mut i32, +} + +fn main() { + let mut point = Point { x: 0, y: 0 }; + + { + let r = PointRef { x: &mut point.x, y: &mut point.y }; + + *r.x = 5; + *r.y = 6; + } + + assert_eq!(5, point.x); + assert_eq!(6, point.y); +} +``` + # Update syntax A `struct` can include `..` to indicate that you want to use a copy of some diff --git a/src/doc/book/the-stack-and-the-heap.md b/src/doc/book/the-stack-and-the-heap.md index 63b73a7fc31fc..bc40eeb8dccfb 100644 --- a/src/doc/book/the-stack-and-the-heap.md +++ b/src/doc/book/the-stack-and-the-heap.md @@ -539,7 +539,7 @@ instead. # Which to use? So if the stack is faster and easier to manage, why do we need the heap? A big -reason is that Stack-allocation alone means you only have LIFO semantics for +reason is that Stack-allocation alone means you only have 'Last In First Out (LIFO)' semantics for reclaiming storage. Heap-allocation is strictly more general, allowing storage to be taken from and returned to the pool in arbitrary order, but at a complexity cost. diff --git a/src/libcore/char.rs b/src/libcore/char.rs index 43a1bf6e500c0..0fc154a0cd591 100644 --- a/src/libcore/char.rs +++ b/src/libcore/char.rs @@ -181,7 +181,7 @@ pub unsafe fn from_u32_unchecked(i: u32) -> char { /// /// A 'radix' here is sometimes also called a 'base'. A radix of two /// indicates a binary number, a radix of ten, decimal, and a radix of -/// sixteen, hexicdecimal, to give some common values. Arbitrary +/// sixteen, hexadecimal, to give some common values. Arbitrary /// radicum are supported. /// /// `from_digit()` will return `None` if the input is not a digit in diff --git a/src/libcore/marker.rs b/src/libcore/marker.rs index b584e59a825ff..65ddae51b98f6 100644 --- a/src/libcore/marker.rs +++ b/src/libcore/marker.rs @@ -24,6 +24,8 @@ use hash::Hash; use hash::Hasher; /// Types that can be transferred across thread boundaries. +/// +/// This trait is automatically derived when the compiler determines it's appropriate. #[stable(feature = "rust1", since = "1.0.0")] #[lang = "send"] #[rustc_on_unimplemented = "`{Self}` cannot be sent between threads safely"] @@ -219,6 +221,8 @@ pub trait Copy : Clone { /// wrapper around the value(s) which can be mutated when behind a `&` /// reference; not doing this is undefined behavior (for example, /// `transmute`-ing from `&T` to `&mut T` is invalid). +/// +/// This trait is automatically derived when the compiler determines it's appropriate. #[stable(feature = "rust1", since = "1.0.0")] #[lang = "sync"] #[rustc_on_unimplemented = "`{Self}` cannot be shared between threads safely"] diff --git a/src/librustc_lint/lib.rs b/src/librustc_lint/lib.rs index 80ef334fe189b..2c15e8f3136ae 100644 --- a/src/librustc_lint/lib.rs +++ b/src/librustc_lint/lib.rs @@ -38,6 +38,7 @@ #![feature(staged_api)] #![feature(str_char)] +#[macro_use] extern crate syntax; #[macro_use] extern crate rustc; @@ -153,4 +154,5 @@ pub fn register_builtins(store: &mut lint::LintStore, sess: Option<&Session>) { store.register_renamed("unknown_features", "unused_features"); store.register_removed("unsigned_negation", "replaced by negate_unsigned feature gate"); + store.register_removed("negate_unsigned", "cast a signed value instead"); } diff --git a/src/librustc_lint/types.rs b/src/librustc_lint/types.rs index a1d029025b2fa..90b71075133cc 100644 --- a/src/librustc_lint/types.rs +++ b/src/librustc_lint/types.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(non_snake_case)] + use middle::{infer}; use middle::def_id::DefId; use middle::subst::Substs; @@ -24,13 +26,19 @@ use std::{i8, i16, i32, i64, u8, u16, u32, u64, f32, f64}; use syntax::{abi, ast}; use syntax::attr::{self, AttrMetaMethods}; use syntax::codemap::{self, Span}; -use syntax::feature_gate::{emit_feature_err, GateIssue}; use syntax::ast::{TyIs, TyUs, TyI8, TyU8, TyI16, TyU16, TyI32, TyU32, TyI64, TyU64}; use rustc_front::hir; use rustc_front::intravisit::{self, Visitor}; use rustc_front::util::is_shift_binop; +register_long_diagnostics! { +E0519: r##" +It is not allowed to negate an unsigned integer. +You can negate a signed integer and cast it to an unsigned integer. +"## +} + declare_lint! { UNUSED_COMPARISONS, Warn, @@ -73,30 +81,24 @@ impl LateLintPass for TypeLimits { fn check_expr(&mut self, cx: &LateContext, e: &hir::Expr) { match e.node { hir::ExprUnary(hir::UnNeg, ref expr) => { - match expr.node { - hir::ExprLit(ref lit) => { - match lit.node { - ast::LitInt(_, ast::UnsignedIntLit(_)) => { - check_unsigned_negation_feature(cx, e.span); - }, - ast::LitInt(_, ast::UnsuffixedIntLit(_)) => { - if let ty::TyUint(_) = cx.tcx.node_id_to_type(e.id).sty { - check_unsigned_negation_feature(cx, e.span); - } - }, - _ => () - } - }, - _ => { - let t = cx.tcx.node_id_to_type(expr.id); - match t.sty { - ty::TyUint(_) => { - check_unsigned_negation_feature(cx, e.span); - }, - _ => () - } + if let hir::ExprLit(ref lit) = expr.node { + match lit.node { + ast::LitInt(_, ast::UnsignedIntLit(_)) => { + forbid_unsigned_negation(cx, e.span); + }, + ast::LitInt(_, ast::UnsuffixedIntLit(_)) => { + if let ty::TyUint(_) = cx.tcx.node_id_to_type(e.id).sty { + forbid_unsigned_negation(cx, e.span); + } + }, + _ => () } - }; + } else { + let t = cx.tcx.node_id_to_type(expr.id); + if let ty::TyUint(_) = t.sty { + forbid_unsigned_negation(cx, e.span); + } + } // propagate negation, if the negation itself isn't negated if self.negated_expr_id != e.id { self.negated_expr_id = expr.id; @@ -322,15 +324,10 @@ impl LateLintPass for TypeLimits { } } - fn check_unsigned_negation_feature(cx: &LateContext, span: Span) { - if !cx.sess().features.borrow().negate_unsigned { - emit_feature_err( - &cx.sess().parse_sess.span_diagnostic, - "negate_unsigned", - span, - GateIssue::Language, - "unary negation of unsigned integers may be removed in the future"); - } + fn forbid_unsigned_negation(cx: &LateContext, span: Span) { + span_err!(cx.sess(), span, E0519, + "unary negation of unsigned integer"); + cx.sess().span_help(span, "use a cast or the `!` operator"); } } } diff --git a/src/librustc_unicode/char.rs b/src/librustc_unicode/char.rs index 455e2feee4c2f..66f8068eae657 100644 --- a/src/librustc_unicode/char.rs +++ b/src/librustc_unicode/char.rs @@ -126,7 +126,7 @@ impl char { /// /// A 'radix' here is sometimes also called a 'base'. A radix of two /// indicates a binary number, a radix of ten, decimal, and a radix of - /// sixteen, hexicdecimal, to give some common values. Arbitrary + /// sixteen, hexadecimal, to give some common values. Arbitrary /// radicum are supported. /// /// Compared to `is_numeric()`, this function only recognizes the characters @@ -185,7 +185,7 @@ impl char { /// /// A 'radix' here is sometimes also called a 'base'. A radix of two /// indicates a binary number, a radix of ten, decimal, and a radix of - /// sixteen, hexicdecimal, to give some common values. Arbitrary + /// sixteen, hexadecimal, to give some common values. Arbitrary /// radicum are supported. /// /// 'Digit' is defined to be only the following characters: diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs index a23dc3b8871fa..4792a1786e11a 100644 --- a/src/libsyntax/feature_gate.rs +++ b/src/libsyntax/feature_gate.rs @@ -170,7 +170,7 @@ const KNOWN_FEATURES: &'static [(&'static str, &'static str, Option, Status ("slice_patterns", "1.0.0", Some(23121), Active), // Allows use of unary negate on unsigned integers, e.g. -e for e: u8 - ("negate_unsigned", "1.0.0", Some(29645), Active), + ("negate_unsigned", "1.0.0", Some(29645), Removed), // Allows the definition of associated constants in `trait` or `impl` // blocks. @@ -540,7 +540,6 @@ pub struct Features { pub allow_pushpop_unsafe: bool, pub simd_ffi: bool, pub unmarked_api: bool, - pub negate_unsigned: bool, /// spans of #![feature] attrs for stable language features. for error reporting pub declared_stable_lang_features: Vec, /// #![feature] attrs for non-language (library) features @@ -577,7 +576,6 @@ impl Features { allow_pushpop_unsafe: false, simd_ffi: false, unmarked_api: false, - negate_unsigned: false, declared_stable_lang_features: Vec::new(), declared_lib_features: Vec::new(), const_fn: false, @@ -1166,7 +1164,6 @@ fn check_crate_inner(cm: &CodeMap, span_handler: &Handler, allow_pushpop_unsafe: cx.has_feature("pushpop_unsafe"), simd_ffi: cx.has_feature("simd_ffi"), unmarked_api: cx.has_feature("unmarked_api"), - negate_unsigned: cx.has_feature("negate_unsigned"), declared_stable_lang_features: accepted_features, declared_lib_features: unknown_features, const_fn: cx.has_feature("const_fn"), diff --git a/src/test/compile-fail/const-eval-overflow.rs b/src/test/compile-fail/const-eval-overflow.rs index daa60955ad88d..2a2fc2ef080db 100644 --- a/src/test/compile-fail/const-eval-overflow.rs +++ b/src/test/compile-fail/const-eval-overflow.rs @@ -9,7 +9,6 @@ // except according to those terms. #![allow(unused_imports)] -#![feature(negate_unsigned)] // Note: the relevant lint pass here runs before some of the constant // evaluation below (e.g. that performed by trans and llvm), so if you @@ -65,7 +64,7 @@ const VALS_I64: (i64, i64, i64, i64) = ); const VALS_U8: (u8, u8, u8, u8) = - (-u8::MIN, + (-(u8::MIN as i8) as u8, u8::MIN - 1, //~^ ERROR attempted to sub with overflow u8::MAX + 1, @@ -75,7 +74,7 @@ const VALS_U8: (u8, u8, u8, u8) = ); const VALS_U16: (u16, u16, u16, u16) = - (-u16::MIN, + (-(u16::MIN as i16) as u16, u16::MIN - 1, //~^ ERROR attempted to sub with overflow u16::MAX + 1, @@ -85,7 +84,7 @@ const VALS_U16: (u16, u16, u16, u16) = ); const VALS_U32: (u32, u32, u32, u32) = - (-u32::MIN, + (-(u32::MIN as i32) as u32, u32::MIN - 1, //~^ ERROR attempted to sub with overflow u32::MAX + 1, @@ -95,7 +94,7 @@ const VALS_U32: (u32, u32, u32, u32) = ); const VALS_U64: (u64, u64, u64, u64) = - (-u64::MIN, + (-(u64::MIN as i64) as u64, u64::MIN - 1, //~^ ERROR attempted to sub with overflow u64::MAX + 1, diff --git a/src/test/compile-fail/const-eval-overflow0.rs b/src/test/compile-fail/const-eval-overflow0.rs new file mode 100644 index 0000000000000..7db7de9cee30c --- /dev/null +++ b/src/test/compile-fail/const-eval-overflow0.rs @@ -0,0 +1,100 @@ +// Copyright 2015 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![allow(unused_imports)] + +// Note: the relevant lint pass here runs before some of the constant +// evaluation below (e.g. that performed by trans and llvm), so if you +// change this warn to a deny, then the compiler will exit before +// those errors are detected. + +use std::fmt; +use std::{i8, i16, i32, i64, isize}; +use std::{u8, u16, u32, u64, usize}; + +const VALS_I8: (i8, i8, i8, i8) = + (-i8::MIN, + i8::MIN - 1, + i8::MAX + 1, + i8::MIN * 2, + ); + +const VALS_I16: (i16, i16, i16, i16) = + (-i16::MIN, + i16::MIN - 1, + i16::MAX + 1, + i16::MIN * 2, + ); + +const VALS_I32: (i32, i32, i32, i32) = + (-i32::MIN, + i32::MIN - 1, + i32::MAX + 1, + i32::MIN * 2, + ); + +const VALS_I64: (i64, i64, i64, i64) = + (-i64::MIN, + i64::MIN - 1, + i64::MAX + 1, + i64::MAX * 2, + ); + +const VALS_U8: (u8, u8, u8, u8) = + (-u8::MIN, + //~^ ERROR unary negation of unsigned integer + //~| HELP use a cast or the `!` operator + u8::MIN - 1, + u8::MAX + 1, + u8::MAX * 2, + ); + +const VALS_U16: (u16, u16, u16, u16) = + (-u16::MIN, + //~^ ERROR unary negation of unsigned integer + //~| HELP use a cast or the `!` operator + u16::MIN - 1, + u16::MAX + 1, + u16::MAX * 2, + ); + +const VALS_U32: (u32, u32, u32, u32) = + (-u32::MIN, + //~^ ERROR unary negation of unsigned integer + //~| HELP use a cast or the `!` operator + u32::MIN - 1, + u32::MAX + 1, + u32::MAX * 2, + ); + +const VALS_U64: (u64, u64, u64, u64) = + (-u64::MIN, + //~^ ERROR unary negation of unsigned integer + //~| HELP use a cast or the `!` operator + u64::MIN - 1, + u64::MAX + 1, + u64::MAX * 2, + ); + +fn main() { + foo(VALS_I8); + foo(VALS_I16); + foo(VALS_I32); + foo(VALS_I64); + + foo(VALS_U8); + foo(VALS_U16); + foo(VALS_U32); + foo(VALS_U64); +} + +fn foo(x: T) { + println!("{:?}", x); +} diff --git a/src/test/compile-fail/enum-discrim-too-small.rs b/src/test/compile-fail/enum-discrim-too-small.rs index cdf7d026d5eeb..84a27a3820069 100644 --- a/src/test/compile-fail/enum-discrim-too-small.rs +++ b/src/test/compile-fail/enum-discrim-too-small.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![feature(negate_unsigned)] #[repr(u8)] //~ NOTE discriminant type specified here enum Eu8 { diff --git a/src/test/compile-fail/feature-gate-negate-unsigned.rs b/src/test/compile-fail/feature-gate-negate-unsigned.rs index b1c73fab4ffa6..15cc17b19db33 100644 --- a/src/test/compile-fail/feature-gate-negate-unsigned.rs +++ b/src/test/compile-fail/feature-gate-negate-unsigned.rs @@ -8,8 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// Test that negating unsigned integers is gated by `negate_unsigned` feature -// gate +// Test that negating unsigned integers doesn't compile struct S; impl std::ops::Neg for S { @@ -18,21 +17,26 @@ impl std::ops::Neg for S { } const _MAX: usize = -1; -//~^ ERROR unary negation of unsigned integers may be removed in the future +//~^ ERROR unary negation of unsigned integer +//~| HELP use a cast or the `!` operator fn main() { let a = -1; - //~^ ERROR unary negation of unsigned integers may be removed in the future + //~^ ERROR unary negation of unsigned integer + //~| HELP use a cast or the `!` operator let _b : u8 = a; // for infering variable a to u8. -a; - //~^ ERROR unary negation of unsigned integers may be removed in the future + //~^ ERROR unary negation of unsigned integer + //~| HELP use a cast or the `!` operator let _d = -1u8; - //~^ ERROR unary negation of unsigned integers may be removed in the future + //~^ ERROR unary negation of unsigned integer + //~| HELP use a cast or the `!` operator for _ in -10..10u8 {} - //~^ ERROR unary negation of unsigned integers may be removed in the future + //~^ ERROR unary negation of unsigned integer + //~| HELP use a cast or the `!` operator -S; // should not trigger the gate; issue 26840 } diff --git a/src/test/compile-fail/lint-type-limits.rs b/src/test/compile-fail/lint-type-limits.rs index 839d50ae63f90..0b414ad73db6f 100644 --- a/src/test/compile-fail/lint-type-limits.rs +++ b/src/test/compile-fail/lint-type-limits.rs @@ -8,9 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![feature(negate_unsigned)] #![allow(dead_code)] -#![feature(negate_unsigned)] // compile-flags: -D unused-comparisons fn main() { } diff --git a/src/test/run-pass/bitwise.rs b/src/test/run-pass/bitwise.rs index a9f19c12b0278..ac24ed8d91604 100644 --- a/src/test/run-pass/bitwise.rs +++ b/src/test/run-pass/bitwise.rs @@ -8,16 +8,14 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![feature(negate_unsigned)] - #[cfg(any(target_arch = "x86", target_arch = "arm"))] fn target() { - assert_eq!(-1000 as usize >> 3_usize, 536870787_usize); + assert_eq!(-1000isize as usize >> 3_usize, 536870787_usize); } #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] fn target() { - assert_eq!(-1000 as usize >> 3_usize, 2305843009213693827_usize); + assert_eq!(-1000isize as usize >> 3_usize, 2305843009213693827_usize); } fn general() { diff --git a/src/test/run-pass/intrinsics-integer.rs b/src/test/run-pass/intrinsics-integer.rs index 170a6c95aa8a8..759dc515456de 100644 --- a/src/test/run-pass/intrinsics-integer.rs +++ b/src/test/run-pass/intrinsics-integer.rs @@ -8,8 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. - -#![feature(negate_unsigned)] #![feature(intrinsics)] mod rusti { @@ -45,10 +43,10 @@ pub fn main() { assert_eq!(ctpop(100u32), 3); assert_eq!(ctpop(100i32), 3); assert_eq!(ctpop(100u64), 3); assert_eq!(ctpop(100i64), 3); - assert_eq!(ctpop(-1u8), 8); assert_eq!(ctpop(-1i8), 8); - assert_eq!(ctpop(-1u16), 16); assert_eq!(ctpop(-1i16), 16); - assert_eq!(ctpop(-1u32), 32); assert_eq!(ctpop(-1i32), 32); - assert_eq!(ctpop(-1u64), 64); assert_eq!(ctpop(-1i64), 64); + assert_eq!(ctpop(-1i8 as u8), 8); assert_eq!(ctpop(-1i8), 8); + assert_eq!(ctpop(-1i16 as u16), 16); assert_eq!(ctpop(-1i16), 16); + assert_eq!(ctpop(-1i32 as u32), 32); assert_eq!(ctpop(-1i32), 32); + assert_eq!(ctpop(-1i64 as u64), 64); assert_eq!(ctpop(-1i64), 64); assert_eq!(ctlz(0u8), 8); assert_eq!(ctlz(0i8), 8); assert_eq!(ctlz(0u16), 16); assert_eq!(ctlz(0i16), 16); @@ -70,10 +68,10 @@ pub fn main() { assert_eq!(ctlz(100u32), 25); assert_eq!(ctlz(100i32), 25); assert_eq!(ctlz(100u64), 57); assert_eq!(ctlz(100i64), 57); - assert_eq!(cttz(-1u8), 0); assert_eq!(cttz(-1i8), 0); - assert_eq!(cttz(-1u16), 0); assert_eq!(cttz(-1i16), 0); - assert_eq!(cttz(-1u32), 0); assert_eq!(cttz(-1i32), 0); - assert_eq!(cttz(-1u64), 0); assert_eq!(cttz(-1i64), 0); + assert_eq!(cttz(-1i8 as u8), 0); assert_eq!(cttz(-1i8), 0); + assert_eq!(cttz(-1i16 as u16), 0); assert_eq!(cttz(-1i16), 0); + assert_eq!(cttz(-1i32 as u32), 0); assert_eq!(cttz(-1i32), 0); + assert_eq!(cttz(-1i64 as u64), 0); assert_eq!(cttz(-1i64), 0); assert_eq!(cttz(0u8), 8); assert_eq!(cttz(0i8), 8); assert_eq!(cttz(0u16), 16); assert_eq!(cttz(0i16), 16); diff --git a/src/test/run-pass/unary-minus-suffix-inference.rs b/src/test/run-pass/unary-minus-suffix-inference.rs index fdb70fe248eff..cff260c3ba63e 100644 --- a/src/test/run-pass/unary-minus-suffix-inference.rs +++ b/src/test/run-pass/unary-minus-suffix-inference.rs @@ -8,8 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![feature(negate_unsigned)] - pub fn main() { let a = 1; let a_neg: i8 = -a; @@ -30,26 +28,4 @@ pub fn main() { let e = 1; let e_neg: isize = -e; println!("{}", e_neg); - - // intentional overflows - - let f = 1; - let f_neg: u8 = -f; - println!("{}", f_neg); - - let g = 1; - let g_neg: u16 = -g; - println!("{}", g_neg); - - let h = 1; - let h_neg: u32 = -h; - println!("{}", h_neg); - - let i = 1; - let i_neg: u64 = -i; - println!("{}", i_neg); - - let j = 1; - let j_neg: usize = -j; - println!("{}", j_neg); }