Unique pointers, unique closures, move semantics

Interface-constrained generics

Static interface dispatch

Stack growth

Multithread task scheduling

Typestate predicates

Failure unwinding, destructors

Pattern matching and destructuring assignment

Lightweight block-lambda syntax

Preliminary macro-by-example

Linux: x86 and x86_64 hosts and targets

macOS: x86 and x86_64 hosts and targets

Windows: x86 hosts and targets

• Cross compilation / multi-target configuration supported.

• Preliminary API-documentation and package-management tools included.

Documentation is incomplete.

Performance is below intended target.

Standard library APIs are subject to extensive change, reorganization.

Language-level versioning is not yet operational - future code will break unexpectedly.

Generics now specialized, multiply instantiated

Functions now inlined across separate crates

Noticeably improved message-passing performance

Explicit schedulers

Callbacks from C

Helgrind clean

Operator overloading

Region pointers

Classes

C-callback function types: 'crust fn ...'

Infinite-loop construct: 'loop { ... }'

Shorten 'mutable' to 'mut'

Required mutable-local qualifier: 'let mut ...'

Basic glob-exporting: 'export foo::*;'

Alt now exhaustive, 'alt check' for runtime-checked

Block-function form of 'for' loop, with 'break' and 'ret'.

AST quasi-quote syntax extension

Revived libuv interface

New modules: core::{future, iter}, std::arena

Merged per-platform std::{os*, fs*} to core::{libc, os}

Extensive cleanup, regularization in libstd, libcore

Integer-literal suffix inference

Per-item control over warnings, errors

#[cfg(windows)] and #[cfg(unix)] attributes

Documentation comments

More compact closure syntax

'do' expressions for treating higher-order functions as control structures

*-patterns (wildcard extended to all constructor fields)

Name resolution pass and exhaustiveness checker rewritten

Region pointers and borrow checking supersede alias analysis

Init-ness checking is now provided by a region-based liveness pass instead of the typestate pass; same for last-use analysis

Extensive work on region pointers

Slices and fixed-size, interior-allocated vectors

#!-comments for lang versioning, shell execution

Destructors and iface implementation for classes; type-parameterized classes and class methods

'const' type kind for types that can be used to implement shared-memory concurrency patterns

Keywords: 'be', 'prove', 'syntax', 'note', 'mutable', 'bind', 'crust', 'native' (now 'extern'), 'cont' (now 'again')

Constructs: do-while loops ('do' repurposed), fn binding, resources (replaced by destructors)

Syntax-layer of compiler split into separate crate

Clang (from LLVM project) integrated into build

Typechecker split into sub-modules

New time functions

Extension methods for many built-in types

Arc: atomic-refcount read-only / exclusive-use shared cells

Par: parallel map and search routines

Extensive work on libuv interface

Much vector code moved to libraries

Syntax extensions: #line, #col, #file, #mod, #stringify, #include, #include_str, #include_bin

Cargo automatically resolves dependencies

All keywords are now strict and may not be used as identifiers anywhere

Keyword removal: 'again', 'import', 'check', 'new', 'owned', 'send', 'of', 'with', 'to', 'class'.

Classes are replaced with simpler structs

Explicit method self types

ret became return and alt became match

import is now use; use is now extern mod`

extern mod { ... } is now extern { ... }

use mod is the recommended way to import modules

pub and priv replace deprecated export lists

The syntax of match pattern arms now uses fat arrow (=>)

main no longer accepts an args vector; use os::args instead

Trait implementations are now coherent, ala Haskell typeclasses

Trait methods may be static

Argument modes are deprecated

Borrowed pointers are much more mature and recommended for use

Strings and vectors in the static region are stored in constant memory

Typestate was removed

Resolution rewritten to be more reliable

Support for 'dual-mode' data structures (freezing and thawing)

Most binary operators can now be overloaded via the traits in `core::ops'

std::net::url for representing URLs

Sendable hash maps in core::send_map

`core::task' gained a (currently unsafe) task-local storage API

An efficient new intertask communication primitive called the pipe, along with a number of higher-level channel types, in core::pipes

std::arc, an atomically reference counted, immutable, shared memory type

std::sync, various exotic synchronization tools based on arcs and pipes

Futures are now based on pipes and sendable

More robust linked task failure

Improved task builder API

Improved error reporting

Preliminary JIT support

Preliminary work on precise GC

Extensive architectural improvements to rustc

Begun a transition away from buggy C++-based reflection (shape) code to Rust-based (visitor) code

All hash functions and tables converted to secure, randomized SipHash

Removed <- move operator

Completed the transition from the #fmt extension syntax to fmt!

Removed old fixed length vector syntax - [T]/N

New token-based quasi-quoters, quote_tokens!, quote_expr!, etc.

Macros may now expand to items and statements

a.b() is always parsed as a method call, never as a field projection

Eq and IterBytes implementations can be automatically generated with #[deriving_eq] and #[deriving_iter_bytes] respectively

Removed the special crate language for .rc files

Function arguments may consist of any irrefutable pattern

& and ~ pointers may point to objects

Tuple structs - struct Foo(Bar, Baz). Will replace newtype enums.

Enum variants may be structs

Destructors can be added to all nominal types with the Drop trait

Structs and nullary enum variants may be constants

Values that cannot be implicitly copied are now automatically moved without writing move explicitly

&T may now be coerced to *T

Coercions happen in let statements as well as function calls

use statements now take crate-relative paths

The module and type namespaces have been merged so that static method names can be resolved under the trait in which they are declared

Trait inheritance works in many scenarios

More support for explicit self arguments in methods - self, &self @self, and ~self all generally work as expected

Static methods work in more situations

Experimental: Traits may declare default methods for the implementations to use

New condition handling system in core::condition

Timsort added to std::sort

New priority queue, std::priority_queue

Pipes for serializable types, `std::flatpipes'

Serialization overhauled to be trait-based

Expanded getopts definitions

Moved futures to std

More functions are pure now

core::comm renamed to oldcomm. Still deprecated

rustdoc and cargo are libraries now

Added a preliminary REPL, rusti

License changed from MIT to dual MIT/APL2

The self type parameter in traits is now spelled Self

The self parameter in trait and impl methods must now be explicitly named (for example: fn f(&self) { }). Implicit self is deprecated.

Static methods no longer require the static keyword and instead are distinguished by the lack of a self parameter

Replaced the Durable trait with the 'static lifetime

The old closure type syntax with the trailing sigil has been removed in favor of the more consistent leading sigil

super is a keyword, and may be prefixed to paths

Trait bounds are separated with + instead of whitespace

Traits are implemented with impl Trait for Type instead of impl Type: Trait

Lifetime syntax is now &'l foo instead of &l/foo

The export keyword has finally been removed

The move keyword has been removed (see "Semantic changes")

The interior mutability qualifier on vectors, [mut T], has been removed. Use &mut [T], etc.

mut is no longer valid in ~mut T. Use inherited mutability

fail is no longer a keyword. Use fail!()

assert is no longer a keyword. Use assert!()

log is no longer a keyword. use debug!, etc.

1-tuples may be represented as (T,)

Struct fields may no longer be mut. Use inherited mutability, @mut T, core::mut or core::cell

extern mod { ... } is no longer valid syntax for foreign function modules. Use extern blocks: extern { ... }

Newtype enums removed. Use tuple-structs.

Trait implementations no longer support visibility modifiers

Pattern matching over vectors improved and expanded

const renamed to static to correspond to lifetime name, and make room for future static mut unsafe mutable globals.

Replaced #[deriving_eq] with #[deriving(Eq)], etc.

Clone implementations can be automatically generated with #[deriving(Clone)]

Casts to traits must use a pointer sigil, e.g. @foo as @Bar instead of foo as Bar.

Fixed length vector types are now written as [int, .. 3] instead of [int * 3].

Fixed length vector types can express the length as a constant expression. (ex: [int, .. GL_BUFFER_SIZE - 2])

Types with owned pointers or custom destructors move by default, eliminating the move keyword

All foreign functions are considered unsafe

&mut is now unaliasable

Writes to borrowed @mut pointers are prevented dynamically

() has size 0

The name of the main function can be customized using #[main]

The default type of an inferred closure is &fn instead of @fn

use statements may no longer be "chained" - they cannot import identifiers imported by previous use statements

use statements are crate relative, importing from the "top" of the crate by default. Paths may be prefixed with super:: or self:: to change the search behavior.

Method visibility is inherited from the implementation declaration

Structural records have been removed

Many more types can be used in static items, including enums 'static-lifetime pointers and vectors

Pattern matching over vectors improved and expanded

Typechecking of closure types has been overhauled to improve inference and eliminate unsoundness

Macros leave scope at the end of modules, unless that module is tagged with #[macro_escape]

Added big integers to std::bigint

Removed core::oldcomm module

Added pipe-based core::comm module

Numeric traits have been reorganized under core::num

vec::slice finally returns a slice

debug! and friends don't require a format string, e.g. debug!(Foo)

Containers reorganized around traits in core::container

core::dvec removed, ~[T] is a drop-in replacement

core::send_map renamed to core::hashmap

std::map removed; replaced with core::hashmap

std::treemap reimplemented as an owned balanced tree

std::deque and std::smallintmap reimplemented as owned containers

core::trie added as a fast ordered map for integer keys

Set types added to core::hashmap, core::trie and std::treemap

Ord split into Ord and TotalOrd. Ord is still used to overload the comparison operators, whereas TotalOrd is used by certain container types

Replaced the 'cargo' package manager with 'rustpkg'

Added all-purpose 'rust' tool

rustc --test now supports benchmarks with the #[bench] attribute

rustc now attempts to offer spelling suggestions

Improved support for ARM and Android

Preliminary MIPS backend

Improved foreign function ABI implementation for x86, x86_64

Various memory usage improvements

Rust code may be embedded in foreign code under limited circumstances

Inline assembler supported by new asm!() syntax extension.

impls no longer accept a visibility qualifier. Put them on methods instead.

The borrow checker has been rewritten with flow-sensitivity, fixing many bugs and inconveniences.

The self parameter no longer implicitly means &'self self, and can be explicitly marked with a lifetime.

Overloadable compound operators (+=, etc.) have been temporarily removed due to bugs.

The for loop protocol now requires for-iterators to return bool so they compose better.

The Durable trait is replaced with the 'static bounds.

Trait default methods work more often.

Structs with the #[packed] attribute have byte alignment and no padding between fields.

Type parameters bound by Copy must now be copied explicitly with the copy keyword.

It is now illegal to move out of a dereferenced unsafe pointer.

Option<~T> is now represented as a nullable pointer.

@mut does dynamic borrow checks correctly.

The main function is only detected at the topmost level of the crate. The #[main] attribute is still valid anywhere.

Struct fields may no longer be mutable. Use inherited mutability.

The #[no_send] attribute makes a type that would otherwise be Send, not.

The #[no_freeze] attribute makes a type that would otherwise be Freeze, not.

Unbounded recursion will abort the process after reaching the limit specified by the RUST_MAX_STACK environment variable (default: 1GB).

The vecs_implicitly_copyable lint mode has been removed. Vectors are never implicitly copyable.

#[static_assert] makes compile-time assertions about static bools.

At long last, 'argument modes' no longer exist.

The rarely used use mod statement no longer exists.

fail! and assert! accept ~str, &'static str or fmt!-style argument list.

Encodable, Decodable, Ord, TotalOrd, TotalEq, DeepClone, Rand, Zero and ToStr can all be automatically derived with #[deriving(...)].

The bytes! macro returns a vector of bytes for string, u8, char, and unsuffixed integer literals.

The core crate was renamed to std.

The std crate was renamed to extra.

More and improved documentation.

std: iterator module for external iterator objects.

Many old-style (internal, higher-order function) iterators replaced by implementations of Iterator.

std: Many old internal vector and string iterators, incl. any, all. removed.

std: The finalize method of Drop renamed to drop.

std: The drop method now takes &mut self instead of &self.

std: The prelude no longer re-exports any modules, only types and traits.

std: Prelude additions: print, println, FromStr, ApproxEq, Equiv, Iterator, IteratorUtil, many numeric traits, many tuple traits.

std: New numeric traits: Fractional, Real, RealExt, Integer, Ratio, Algebraic, Trigonometric, Exponential, Primitive.

std: Tuple traits and accessors defined for up to 12-tuples, e.g. (0, 1, 2).n2() or (0, 1, 2).n2_ref().

std: Many types implement Clone.

std: path type renamed to Path.

std: mut module and Mut type removed.

std: Many standalone functions removed in favor of methods and iterators in vec, str. In the future methods will also work as functions.

std: reinterpret_cast removed. Use transmute.

std: ascii string handling in std::ascii.

std: Rand is implemented for ~/@.

std: run module for spawning processes overhauled.

std: Various atomic types added to unstable::atomic.

std: Various types implement Zero.

std: LinearMap and LinearSet renamed to HashMap and HashSet.

std: Borrowed pointer functions moved from ptr to borrow.

std: Added os::mkdir_recursive.

std: Added os::glob function performs filesystems globs.

std: FuzzyEq renamed to ApproxEq.

std: Map now defines pop and swap methods.

std: Cell constructors converted to static methods.

extra: rc module adds the reference counted pointers, Rc and RcMut.

extra: flate module moved from std to extra.

extra: fileinput module for iterating over a series of files.

extra: Complex number type and complex module.

extra: Rational number type and rational module.

extra: BigInt, BigUint implement numeric and comparison traits.

extra: term uses terminfo now, is more correct.

extra: arc functions converted to methods.

extra: Implementation of fixed output size variations of SHA-2.

unused_variables lint mode for unused variables (default: warn).

unused_unsafe lint mode for detecting unnecessary unsafe blocks (default: warn).

unused_mut lint mode for identifying unused mut qualifiers (default: warn).

dead_assignment lint mode for unread variables (default: warn).

unnecessary_allocation lint mode detects some heap allocations that are immediately borrowed so could be written without allocating (default: warn).

missing_doc lint mode (default: allow).

unreachable_code lint mode (default: warn).

The rusti command has been rewritten and a number of bugs addressed.

rustc outputs in color on more terminals.

rustc accepts a --link-args flag to pass arguments to the linker.

rustc accepts a -Z print-link-args flag for debugging linkage.

Compiling with -g will make the binary record information about dynamic borrowcheck failures for debugging.

rustdoc has a nicer stylesheet.

Various improvements to rustdoc.

Improvements to rustpkg (see the detailed release notes).

The for loop syntax has changed to work with the Iterator trait.

At long last, unwinding works on Windows.

Default methods are ready for use.

Many trait inheritance bugs fixed.

Owned and borrowed trait objects work more reliably.

copy is no longer a keyword. It has been replaced by the Clone trait.

rustc can omit emission of code for the debug! macro if it is passed --cfg ndebug

mod.rs is now "blessed". When loading mod foo;, rustc will now look for foo.rs, then foo/mod.rs, and will generate an error when both are present.

Strings no longer contain trailing nulls. The new std::c_str module provides new mechanisms for converting to C strings.

The type of foreign functions is now extern "C" fn instead of *u8.

The FFI has been overhauled such that foreign functions are called directly, instead of through a stack-switching wrapper.

Calling a foreign function must be done through a Rust function with the #[fixed_stack_segment] attribute.

The externfn! macro can be used to declare both a foreign function and a #[fixed_stack_segment] wrapper at once.

pub and priv modifiers on extern blocks are no longer parsed.

unsafe is no longer allowed on extern fns - they are all unsafe.

priv is disallowed everywhere except for struct fields and enum variants.

&T (besides &'static T) is no longer allowed in @T.

ref bindings in irrefutable patterns work correctly now.

char is now prevented from containing invalid code points.

Casting to bool is no longer allowed.

\0 is now accepted as an escape in chars and strings.

yield is a reserved keyword.

typeof is a reserved keyword.

Crates may be imported by URL with extern mod foo = "url";.

Explicit enum discriminants may be given as uints as in enum E { V = 0u }

Static vectors can be initialized with repeating elements, e.g. static foo: [u8, .. 100]: [0, .. 100];.

Static structs can be initialized with functional record update, e.g. static foo: Foo = Foo { a: 5, .. bar };.

cfg! can be used to conditionally execute code based on the crate configuration, similarly to #[cfg(...)].

The unnecessary_qualification lint detects unneeded module prefixes (default: allow).

Arithmetic operations have been implemented on the SIMD types in std::unstable::simd.

Exchange allocation headers were removed, reducing memory usage.

format! implements a completely new, extensible, and higher-performance string formatting system. It will replace fmt!.

print! and println! write formatted strings (using the format! extension) to stdout.

write! and writeln! write formatted strings (using the format! extension) to the new Writers in std::rt::io.

The library section in which a function or static is placed may be specified with #[link_section = "..."].

The proto! syntax extension for defining bounded message protocols was removed.

macro_rules! is hygienic for let declarations.

The #[export_name] attribute specifies the name of a symbol.

unreachable! can be used to indicate unreachable code, and fails if executed.

std: Transitioned to the new runtime, written in Rust.

std: Added an experimental I/O library, rt::io, based on the new runtime.

std: A new generic range function was added to the prelude, replacing uint::range and friends.

std: range_rev no longer exists. Since range is an iterator it can be reversed with range(lo, hi).invert().

std: The chain method on option renamed to and_then; unwrap_or_default renamed to unwrap_or.

std: The iterator module was renamed to iter.

std: Integral types now support the checked_add, checked_sub, and checked_mul operations for detecting overflow.

std: Many methods in str, vec, option, result were renamed for consistency.

std: Methods are standardizing on conventions for casting methods: to_foo for copying, into_foo for moving, as_foo for temporary and cheap casts.

std: The CString type in c_str provides new ways to convert to and from C strings.

std: DoubleEndedIterator can yield elements in two directions.

std: The mut_split method on vectors partitions an &mut [T] into two splices.

std: str::from_bytes renamed to str::from_utf8.

std: pop_opt and shift_opt methods added to vectors.

std: The task-local data interface no longer uses @, and keys are no longer function pointers.

std: The swap_unwrap method of Option renamed to take_unwrap.

std: Added SharedPort to comm.

std: Eq has a default method for ne; only eq is required in implementations.

std: Ord has default methods for le, gt and ge; only lt is required in implementations.

std: is_utf8 performance is improved, impacting many string functions.

std: os::MemoryMap provides cross-platform mmap.

std: ptr::offset is now unsafe, but also more optimized. Offsets that are not 'in-bounds' are considered undefined.

std: Many freestanding functions in vec removed in favor of methods.

std: Many freestanding functions on scalar types removed in favor of methods.

std: Many options to task builders were removed since they don't make sense in the new scheduler design.

std: More containers implement FromIterator so can be created by the collect method.

std: More complete atomic types in unstable::atomics.

std: comm::PortSet removed.

std: Mutating methods in the Set and Map traits have been moved into the MutableSet and MutableMap traits. Container::is_empty, Map::contains_key, MutableMap::insert, and MutableMap::remove have default implementations.

std: Various from_str functions were removed in favor of a generic from_str which is available in the prelude.

std: util::unreachable removed in favor of the unreachable! macro.

extra: dlist, the doubly-linked list was modernized.

extra: Added a hex module with ToHex and FromHex traits.

extra: Added glob module, replacing std::os::glob.

extra: rope was removed.

extra: deque was renamed to ringbuf. RingBuf implements Deque.

extra: net, and timer were removed. The experimental replacements are std::rt::io::net and std::rt::io::timer.

extra: Iterators implemented for SmallIntMap.

extra: Iterators implemented for Bitv and BitvSet.

extra: SmallIntSet removed. Use BitvSet.

extra: Performance of JSON parsing greatly improved.

extra: semver updated to SemVer 2.0.0.

extra: term handles more terminals correctly.

extra: dbg module removed.

extra: par module removed.

extra: future was cleaned up, with some method renames.

extra: Most free functions in getopts were converted to methods.

rustc's debug info generation (-Z debug-info) is greatly improved.

rustc accepts --target-cpu to compile to a specific CPU architecture, similarly to gcc's --march flag.

rustc's performance compiling small crates is much better.

rustpkg has received many improvements.

rustpkg supports git tags as package IDs.

rustpkg builds into target-specific directories so it can be used for cross-compiling.

The number of concurrent test tasks is controlled by the environment variable RUST_TEST_TASKS.

The test harness can now report metrics for benchmarks.

All tools have man pages.

Programs compiled with --test now support the -h and --help flags.

The runtime uses jemalloc for allocations.

Segmented stacks are temporarily disabled as part of the transition to the new runtime. Stack overflows are possible!

A new documentation backend, rustdoc_ng, is available for use. It is still invoked through the normal rustdoc command.

The float type has been removed. Use f32 or f64 instead.

A new facility for enabling experimental features (feature gating) has been added, using the crate-level #[feature(foo)] attribute.

Managed boxes (@) are now behind a feature gate (#[feature(managed_boxes)]) in preparation for future removal. Use the standard library's Gc or Rc types instead.

@mut has been removed. Use std::cell::{Cell, RefCell} instead.

Jumping back to the top of a loop is now done with continue instead of loop.

Strings can no longer be mutated through index assignment.

Raw strings can be created via the basic r"foo" syntax or with matched hash delimiters, as in r###"foo"###.

~fn is now written proc (args) -> retval { ... } and may only be called once.

The &fn type is now written |args| -> ret to match the literal form.

@fns have been removed.

do only works with procs in order to make it obvious what the cost of do is.

Single-element tuple-like structs can no longer be dereferenced to obtain the inner value. A more comprehensive solution for overloading the dereference operator will be provided in the future.

The #[link(...)] attribute has been replaced with #[crate_id = "name#vers"].

Empty impls must be terminated with empty braces and may not be terminated with a semicolon.

Keywords are no longer allowed as lifetime names; the self lifetime no longer has any special meaning.

The old fmt! string formatting macro has been removed.

printf! and printfln! (old-style formatting) removed in favor of print! and println!.

mut works in patterns now, as in let (mut x, y) = (1, 2);.

The extern mod foo (name = "bar") syntax has been removed. Use extern mod foo = "bar" instead.

New reserved keywords: alignof, offsetof, sizeof.

Macros can have attributes.

Macros can expand to items with attributes.

Macros can expand to multiple items.

The asm! macro is feature-gated (#[feature(asm)]).

Comments may be nested.

Values automatically coerce to trait objects they implement, without an explicit as.

Enum discriminants are no longer an entire word but as small as needed to contain all the variants. The repr attribute can be used to override the discriminant size, as in #[repr(int)] for integer-sized, and #[repr(C)] to match C enums.

Non-string literals are not allowed in attributes (they never worked).

The FFI now supports variadic functions.

Octal numeric literals, as in 0o7777.

The concat! syntax extension performs compile-time string concatenation.

The #[fixed_stack_segment] and #[rust_stack] attributes have been removed as Rust no longer uses segmented stacks.

Non-ascii identifiers are feature-gated (#[feature(non_ascii_idents)]).

Ignoring all fields of an enum variant or tuple-struct is done with .., not *; ignoring remaining fields of a struct is also done with .., not _; ignoring a slice of a vector is done with .., not .._.

rustc supports the "win64" calling convention via extern "win64".

rustc supports the "system" calling convention, which defaults to the preferred convention for the target platform, "stdcall" on 32-bit Windows, "C" elsewhere.

The type_overflow lint (default: warn) checks literals for overflow.

The unsafe_block lint (default: allow) checks for usage of unsafe.

The attribute_usage lint (default: warn) warns about unknown attributes.

The unknown_features lint (default: warn) warns about unknown feature gates.

The dead_code lint (default: warn) checks for dead code.

Rust libraries can be linked statically to one another

#[link_args] is behind the link_args feature gate.

Native libraries are now linked with #[link(name = "foo")]

Native libraries can be statically linked to a rust crate (#[link(name = "foo", kind = "static")]).

Native OS X frameworks are now officially supported (#[link(name = "foo", kind = "framework")]).

The #[thread_local] attribute creates thread-local (not task-local) variables. Currently behind the thread_local feature gate.

The return keyword may be used in closures.

Types that can be copied via a memcpy implement the Pod kind.

The cfg attribute can now be used on struct fields and enum variants.

std: The option and result API's have been overhauled to make them simpler, more consistent, and more composable.

std: The entire std::io module has been replaced with one that is more comprehensive and that properly interfaces with the underlying scheduler. File, TCP, UDP, Unix sockets, pipes, and timers are all implemented.

std: io::util contains a number of useful implementations of Reader and Writer, including NullReader, NullWriter, ZeroReader, TeeReader.

std: The reference counted pointer type extra::rc moved into std.

std: The Gc type in the gc module will replace @ (it is currently just a wrapper around it).

std: The Either type has been removed.

std: fmt::Default can be implemented for any type to provide default formatting to the format! macro, as in format!("{}", myfoo).

std: The rand API continues to be tweaked.

std: The rust_begin_unwind function, useful for inserting breakpoints on failure in gdb, is now named rust_fail.

std: The each_key and each_value methods on HashMap have been replaced by the keys and values iterators.

std: Functions dealing with type size and alignment have moved from the sys module to the mem module.

std: The path module was written and API changed.

std: str::from_utf8 has been changed to cast instead of allocate.

std: starts_with and ends_with methods added to vectors via the ImmutableEqVector trait, which is in the prelude.

std: Vectors can be indexed with the get_opt method, which returns None if the index is out of bounds.

std: Task failure no longer propagates between tasks, as the model was complex, expensive, and incompatible with thread-based tasks.

std: The Any type can be used for dynamic typing.

std: ~Any can be passed to the fail! macro and retrieved via task::try.

std: Methods that produce iterators generally do not have an _iter suffix now.

std: cell::Cell and cell::RefCell can be used to introduce mutability roots (mutable fields, etc.). Use instead of e.g. @mut.

std: util::ignore renamed to prelude::drop.

std: Slices have sort and sort_by methods via the MutableVector trait.

std: vec::raw has seen a lot of cleanup and API changes.

std: The standard library no longer includes any C++ code, and very minimal C, eliminating the dependency on libstdc++.

std: Runtime scheduling and I/O functionality has been factored out into extensible interfaces and is now implemented by two different crates: libnative, for native threading and I/O; and libgreen, for green threading and I/O. This paves the way for using the standard library in more limited embedded environments.

std: The comm module has been rewritten to be much faster, have a simpler, more consistent API, and to work for both native and green threading.

std: All libuv dependencies have been moved into the rustuv crate.

native: New implementations of runtime scheduling on top of OS threads.

native: New native implementations of TCP, UDP, file I/O, process spawning, and other I/O.

green: The green thread scheduler and message passing types are almost entirely lock-free.

extra: The flatpipes module had bitrotted and was removed.

extra: All crypto functions have been removed and Rust now has a policy of not reimplementing crypto in the standard library. In the future crypto will be provided by external crates with bindings to established libraries.

extra: c_vec has been modernized.

extra: The sort module has been removed. Use the sort method on mutable slices.

The rust and rusti commands have been removed, due to lack of maintenance.

rustdoc was completely rewritten.

rustdoc can test code examples in documentation.

rustpkg can test packages with the argument, 'test'.

rustpkg supports arbitrary dependencies, including C libraries.

rustc's support for generating debug info is improved again.

rustc has better error reporting for unbalanced delimiters.

rustc's JIT support was removed due to bitrot.

Executables and static libraries can be built with LTO (-Z lto)

rustc adds a --dep-info flag for communicating dependencies to build tools.

A new RFC process is now in place for modifying the language.

Patterns with @-pointers have been removed from the language.

Patterns with unique vectors (~[T]) have been removed from the language.

Patterns with unique strings (~str) have been removed from the language.

@str has been removed from the language.

@[T] has been removed from the language.

@self has been removed from the language.

@Trait has been removed from the language.

Headers on ~ allocations which contain @ boxes inside the type for reference counting have been removed.

The semantics around the lifetimes of temporary expressions have changed, see #3511 and #11585 for more information.

Cross-crate syntax extensions are now possible, but feature gated. See #11151 for more information. This includes both macro_rules! macros as well as syntax extensions such as format!.

New lint modes have been added, and older ones have been turned on to be warn-by-default.

• Unnecessary parentheses

• Uppercase statics

• Camel Case types

• Uppercase variables

• Publicly visible private types

• #[deriving] with raw pointers

Unsafe functions can no longer be coerced to closures.

Various obscure macros such as log_syntax! are now behind feature gates.

The #[simd] attribute is now behind a feature gate.

Visibility is no longer allowed on extern crate statements, and unnecessary visibility (priv) is no longer allowed on use statements.

Trailing commas are now allowed in argument lists and tuple patterns.

The do keyword has been removed, it is now a reserved keyword.

Default type parameters have been implemented, but are feature gated.

Borrowed variables through captures in closures are now considered soundly.

extern mod is now extern crate

The Freeze trait has been removed.

The Share trait has been added for types that can be shared among threads.

Labels in macros are now hygienic.

Expression/statement macro invocations can be delimited with {} now.

Treatment of types allowed in static mut locations has been tweaked.

The * and . operators are now overloadable through the Deref and DerefMut traits.

~Trait and proc no longer have Send bounds by default.

Partial type hints are now supported with the _ type marker.

An Unsafe type was introduced for interior mutability. It is now considered undefined to transmute from &T to &mut T without using the Unsafe type.

The #[linkage] attribute was implemented for extern statics/functions.

The inner attribute syntax has changed from #[foo]; to #![foo].

Pod was renamed to Copy.

The libextra library has been removed. It has now been decomposed into component libraries with smaller and more focused nuggets of functionality. The full list of libraries can be found on the documentation index page.

std: std::condition has been removed. All I/O errors are now propagated through the Result type. In order to assist with error handling, a try! macro for unwrapping errors with an early return and a lint for unused results has been added. See #12039 for more information.

std: The vec module has been renamed to slice.

std: A new vector type, Vec, has been added in preparation for DST. This will become the only growable vector in the future.

std: std::io now has more public re-exports. Types such as BufferedReader are now found at std::io::BufferedReader instead of std::io::buffered::BufferedReader.

std: print and println are no longer in the prelude, the print! and println! macros are intended to be used instead.

std: Rc now has a Weak pointer for breaking cycles, and it no longer attempts to statically prevent cycles.

std: The standard distribution is adopting the policy of pushing failure to the user rather than failing in libraries. Many functions (such as slice::last()) now return Option instead of T + failing.

std: fmt::Default has been renamed to fmt::Show, and it now has a new deriving mode: #[deriving(Show)].

std: ToStr is now implemented for all types implementing Show.

std: The formatting trait methods now take &self instead of &T

std: The invert() method on iterators has been renamed to rev()

std: std::num has seen a reduction in the genericity of its traits, consolidating functionality into a few core traits.

std: Backtraces are now printed on task failure if the environment variable RUST_BACKTRACE is present.

std: Naming conventions for iterators have been standardized. More details can be found on the wiki's style guide.

std: eof() has been removed from the Reader trait. Specific types may still implement the function.

std: Networking types are now cloneable to allow simultaneous reads/writes.

std: assert_approx_eq! has been removed

std: The e and E formatting specifiers for floats have been added to print them in exponential notation.

std: The Times trait has been removed

std: Indications of variance and opting out of builtin bounds is done through marker types in std::kinds::marker now

std: hash has been rewritten, IterBytes has been removed, and #[deriving(Hash)] is now possible.

std: SharedChan has been removed, Sender is now cloneable.

std: Chan and Port were renamed to Sender and Receiver.

std: Chan::new is now channel().

std: A new synchronous channel type has been implemented.

std: A select! macro is now provided for selecting over Receivers.

std: hashmap and trie have been moved to libcollections

std: run has been rolled into io::process

std: assert_eq! now uses {} instead of {:?}

std: The equality and comparison traits have seen some reorganization.

std: rand has moved to librand.

std: to_{lower,upper}case has been implemented for char.

std: Logging has been moved to liblog.

collections: HashMap has been rewritten for higher performance and less memory usage.

native: The default runtime is now libnative. If libgreen is desired, it can be booted manually. The runtime guide has more information and examples.

native: All I/O functionality except signals has been implemented.

green: Task spawning with libgreen has been optimized with stack caching and various trimming of code.

green: Tasks spawned by libgreen now have an unmapped guard page.

sync: The extra::sync module has been updated to modern rust (and moved to the sync library), tweaking and improving various interfaces while dropping redundant functionality.

sync: A new Barrier type has been added to the sync library.

sync: An efficient mutex for native and green tasks has been implemented.

serialize: The base64 module has seen some improvement. It treats newlines better, has non-string error values, and has seen general cleanup.

fourcc: A fourcc! macro was introduced

hexfloat: A hexfloat! macro was implemented for specifying floats via a hexadecimal literal.

rustpkg has been deprecated and removed from the main repository. Its replacement, cargo, is under development.

Nightly builds of rust are now available

The memory usage of rustc has been improved many times throughout this release cycle.

The build process supports disabling rpath support for the rustc binary itself.

Code generation has improved in some cases, giving more information to the LLVM optimization passes to enable more extensive optimizations.

Debuginfo compatibility with lldb on OSX has been restored.

The master branch is now gated on an android bot, making building for android much more reliable.

Output flags have been centralized into one --emit flag.

Crate type flags have been centralized into one --crate-type flag.

Codegen flags have been consolidated behind a -C flag.

Linking against outdated crates now has improved error messages.

Error messages with lifetimes will often suggest how to annotate the function to fix the error.

Many more types are documented in the standard library, and new guides were written.

Many rustdoc improvements:

• code blocks are syntax highlighted.

• render standalone markdown files.

• the --test flag tests all code blocks by default.

• exported macros are displayed.

• re-exported types have their documentation inlined at the location of the first re-export.

• search works across crates that have been rendered to the same output directory.

~[T] has been removed from the language. This type is superseded by the Vec type.

~str has been removed from the language. This type is superseded by the String type.

~T has been removed from the language. This type is superseded by the Box type.

@T has been removed from the language. This type is superseded by the standard library's std::gc::Gc type.

Struct fields are now all private by default.

Vector indices and shift amounts are both required to be a uint instead of any integral type.

Byte character, byte string, and raw byte string literals are now all supported by prefixing the normal literal with a b.

Multiple ABIs are no longer allowed in an ABI string

The syntax for lifetimes on closures/procedures has been tweaked slightly: <'a>|A, B|: 'b + K -> T

Floating point modulus has been removed from the language; however it is still provided by a library implementation.

Private enum variants are now disallowed.

The priv keyword has been removed from the language.

A closure can no longer be invoked through a &-pointer.

The use foo, bar, baz; syntax has been removed from the language.

The transmute intrinsic no longer works on type parameters.

Statics now allow blocks/items in their definition.

Trait bounds are separated from objects with + instead of : now.

Objects can no longer be read while they are mutably borrowed.

The address of a static is now marked as insignificant unless the #[inline(never)] attribute is placed it.

The #[unsafe_destructor] attribute is now behind a feature gate.

Struct literals are no longer allowed in ambiguous positions such as if, while, match, and for..in.

Declaration of lang items and intrinsics are now feature-gated by default.

Integral literals no longer default to int, and floating point literals no longer default to f64. Literals must be suffixed with an appropriate type if inference cannot determine the type of the literal.

The Box type is no longer implicitly borrowed to &mut T.

Procedures are now required to not capture borrowed references.

The standard library is now a "facade" over a number of underlying libraries. This means that development on the standard library should be speedier due to smaller crates, as well as a clearer line between all dependencies.

A new library, libcore, lives under the standard library's facade which is Rust's "0-assumption" library, suitable for embedded and kernel development for example.

A regex crate has been added to the standard distribution. This crate includes statically compiled regular expressions.

The unwrap/unwrap_err methods on Result require a Show bound for better error messages.

The return types of the std::comm primitives have been centralized around the Result type.

A number of I/O primitives have gained the ability to time out their operations.

A number of I/O primitives have gained the ability to close their reading/writing halves to cancel pending operations.

Reverse iterator methods have been removed in favor of rev() on their forward-iteration counterparts.

A bitflags! macro has been added to enable easy interop with C and management of bit flags.

A debug_assert! macro is now provided which is disabled when --cfg ndebug is passed to the compiler.

A graphviz crate has been added for creating .dot files.

The std::cast module has been migrated into std::mem.

The std::local_data api has been migrated from freestanding functions to being based on methods.

The Pod trait has been renamed to Copy.

jemalloc has been added as the default allocator for types.

The API for allocating memory has been changed to use proper alignment and sized deallocation

Connecting a TcpStream or binding a TcpListener is now based on a string address and a u16 port. This allows connecting to a hostname as opposed to an IP.

The Reader trait now contains a core method, read_at_least(), which correctly handles many repeated 0-length reads.

The process-spawning API is now centered around a builder-style Command struct.

The :? printing qualifier has been moved from the standard library to an external libdebug crate.

Eq/Ord have been renamed to PartialEq/PartialOrd. TotalEq/TotalOrd have been renamed to Eq/Ord.

The select/plural methods have been removed from format!. The escapes for { and } have also changed from { and } to {{ and }}, respectively.

The TaskBuilder API has been re-worked to be a true builder, and extension traits for spawning native/green tasks have been added.

All breaking changes to the language or libraries now have their commit message annotated with [breaking-change] to allow for easy discovery of breaking changes.

The compiler will now try to suggest how to annotate lifetimes if a lifetime-related error occurs.

Debug info continues to be improved greatly with general bug fixes and better support for situations like link time optimization (LTO).

Usage of syntax extensions when cross-compiling has been fixed.

Functionality equivalent to GCC & Clang's -ffunction-sections, -fdata-sections and --gc-sections has been enabled by default

The compiler is now stricter about where it will load module files from when a module is declared via mod foo;.

The #[phase(syntax)] attribute has been renamed to #[phase(plugin)]. Syntax extensions are now discovered via a "plugin registrar" type which will be extended in the future to other various plugins.

Lints have been restructured to allow for dynamically loadable lints.

A number of rustdoc improvements:

• The HTML output has been visually redesigned.

• Markdown is now powered by hoedown instead of sundown.

• Searching heuristics have been greatly improved.

• The search index has been reduced in size by a great amount.

• Cross-crate documentation via pub use has been greatly improved.

• Primitive types are now hyperlinked and documented.

Documentation has been moved from static.rust-lang.org/doc to doc.rust-lang.org

A new sandbox, play.rust-lang.org, is available for running and sharing rust code examples on-line.

Unused attributes are now more robustly warned about.

The dead_code lint now warns about unused struct fields.

Cross-compiling to iOS is now supported.

Cross-compiling to mipsel is now supported.

Stability attributes are now inherited by default and no longer apply to intra-crate usage, only inter-crate usage.

Error message related to non-exhaustive match expressions have been greatly improved.

The introductory documentation (now called The Rust Guide) has been completely rewritten, as have a number of supplementary guides.

Rust's package manager, Cargo, continues to improve and is sometimes considered to be quite awesome.

Many API's in std have been reviewed and updated for consistency with the in-development Rust coding guidelines. The standard library documentation tracks stabilization progress.

Minor libraries have been moved out-of-tree to the rust-lang org on GitHub: uuid, semver, glob, num, hexfloat, fourcc. They can be installed with Cargo.

Lifetime elision allows lifetime annotations to be left off of function declarations in many common scenarios.

Rust now works on 64-bit Windows.

Indexing can be overloaded with the Index and IndexMut traits.

The if let construct takes a branch only if the let pattern matches, currently behind the 'if_let' feature gate.

'where clauses', a more flexible syntax for specifying trait bounds that is more aesthetic, have been added for traits and free functions. Where clauses will in the future make it possible to constrain associated types, which would be impossible with the existing syntax.

A new slicing syntax (e.g. [0..4]) has been introduced behind the 'slicing_syntax' feature gate, and can be overloaded with the Slice or SliceMut traits.

The syntax for matching of sub-slices has been changed to use a postfix .. instead of prefix (.e.g. [a, b, c..]), for consistency with other uses of .. and to future-proof potential additional uses of the syntax.

The syntax for matching inclusive ranges in patterns has changed from 0..3 to 0...4 to be consistent with the exclusive range syntax for slicing.

Matching of sub-slices in non-tail positions (e.g. [a.., b, c]) has been put behind the 'advanced_slice_patterns' feature gate and may be removed in the future.

Components of tuples and tuple structs can be extracted using the value.0 syntax, currently behind the tuple_indexing feature gate.

The #[crate_id] attribute is no longer supported; versioning is handled by the package manager.

Renaming crate imports are now written extern crate foo as bar instead of extern crate bar = foo.

Renaming use statements are now written use foo as bar instead of use bar = foo.

let and match bindings and argument names in macros are now hygienic.

The new, more efficient, closure types ('unboxed closures') have been added under a feature gate, 'unboxed_closures'. These will soon replace the existing closure types, once higher-ranked trait lifetimes are added to the language.

move has been added as a keyword, for indicating closures that capture by value.

Mutation and assignment is no longer allowed in pattern guards.

Generic structs and enums can now have trait bounds.

The Share trait is now called Sync to free up the term 'shared' to refer to 'shared reference' (the default reference type.

Dynamically-sized types have been mostly implemented, unifying the behavior of fat-pointer types with the rest of the type system.

As part of dynamically-sized types, the Sized trait has been introduced, which qualifying types implement by default, and which type parameters expect by default. To specify that a type parameter does not need to be sized, write <Sized? T>. Most types are Sized, notable exceptions being unsized arrays ([T]) and trait types.

Closures can return !, as in || -> ! or proc() -> !.

Lifetime bounds can now be applied to type parameters and object types.

The old, reference counted GC type, Gc which was once denoted by the @ sigil, has finally been removed. GC will be revisited in the future.

Library documentation has been improved for a number of modules.

Bit-vectors, collections::bitv has been modernized.

The url crate is deprecated in favor of http://github.com/servo/rust-url, which can be installed with Cargo.

Most I/O stream types can be cloned and subsequently closed from a different thread.

A std::time::Duration type has been added for use in I/O methods that rely on timers, as well as in the 'time' crate's Timespec arithmetic.

The runtime I/O abstraction layer that enabled the green thread scheduler to do non-thread-blocking I/O has been removed, along with the libuv-based implementation employed by the green thread scheduler. This will greatly simplify the future I/O work.

collections::btree has been rewritten to have a more idiomatic and efficient design.

rustdoc output now indicates the stability levels of API's.

The --crate-name flag can specify the name of the crate being compiled, like #[crate_name].

The -C metadata specifies additional metadata to hash into symbol names, and -C extra-filename specifies additional information to put into the output filename, for use by the package manager for versioning.

debug info generation has continued to improve and should be more reliable under both gdb and lldb.

rustc has experimental support for compiling in parallel using the -C codegen-units flag.

rustc no longer encodes rpath information into binaries by default.

Stack usage has been optimized with LLVM lifetime annotations.

Official Rust binaries on Linux are more compatible with older kernels and distributions, built on CentOS 5.10.

The language itself is considered feature complete for 1.0, though there will be many usability improvements and bugfixes before the final release.

Nearly 50% of the public API surface of the standard library has been declared 'stable'. Those interfaces are unlikely to change before 1.0.

The long-running debate over integer types has been settled: Rust will ship with types named isize and usize, rather than int and uint, for pointer-sized integers. Guidelines will be rolled out during the alpha cycle.

Most crates that are not std have been moved out of the Rust distribution into the Cargo ecosystem so they can evolve separately and don't need to be stabilized as quickly, including 'time', 'getopts', 'num', 'regex', and 'term'.

Documentation continues to be expanded with more API coverage, more examples, and more in-depth explanations. The guides have been consolidated into The Rust Programming Language.

"Rust By Example" is now maintained by the Rust team.

All official Rust binary installers now come with Cargo, the Rust package manager.

Closures have been completely redesigned to be implemented in terms of traits, can now be used as generic type bounds and thus monomorphized and inlined, or via an opaque pointer (boxed) as in the old system. The new system is often referred to as 'unboxed' closures.

Traits now support associated types, allowing families of related types to be defined together and used generically in powerful ways.

Enum variants are namespaced by their type names.

where clauses provide a more versatile and attractive syntax for specifying generic bounds, though the previous syntax remains valid.

Rust again picks a fallback (either i32 or f64) for uninferred numeric types.

Rust no longer has a runtime of any description, and only supports OS threads, not green threads.

At long last, Rust has been overhauled for 'dynamically-sized types' (DST), which integrates 'fat pointers' (object types, arrays, and str) more deeply into the type system, making it more consistent.

Rust now has a general range syntax, i..j, i.., and ..j that produce range types and which, when combined with the Index operator and multidispatch, leads to a convenient slice notation, [i..j].

The new range syntax revealed an ambiguity in the fixed-length array syntax, so now fixed length arrays are written [T; N].

The Copy trait is no longer implemented automatically. Unsafe pointers no longer implement Sync and Send so types containing them don't automatically either. Sync and Send are now 'unsafe traits' so one can "forcibly" implement them via unsafe impl if a type confirms to the requirements for them even though the internals do not (e.g. structs containing unsafe pointers like Arc). These changes are intended to prevent some footguns and are collectively known as opt-in built-in traits (though Sync and Send will soon become pure library types unknown to the compiler).

Operator traits now take their operands by value, and comparison traits can use multidispatch to compare one type against multiple other types, allowing e.g. String to be compared with &str.

if let and while let are no longer feature-gated.

Rust has adopted a more uniform syntax for escaping unicode characters.

macro_rules! has been declared stable. Though it is a flawed system it is sufficiently popular that it must be usable for 1.0. Effort has gone into future-proofing it in ways that will allow other macro systems to be developed in parallel, and won't otherwise impact the evolution of the language.

The prelude has been pared back significantly such that it is the minimum necessary to support the most pervasive code patterns, and through generalized where clauses many of the prelude extension traits have been consolidated.

Rust's rudimentary reflection has been removed, as it incurred too much code generation for little benefit.

Struct variants are no longer feature-gated.

Trait bounds can be polymorphic over lifetimes. Also known as 'higher-ranked trait bounds', this crucially allows unboxed closures to work.

Macros invocations surrounded by parens or square brackets and not terminated by a semicolon are parsed as expressions, which makes expressions like vec![1i32, 2, 3].len() work as expected.

Trait objects now implement their traits automatically, and traits that can be coerced to objects now must be object safe.

Automatically deriving traits is now done with #[derive(...)] not #[deriving(...)] for consistency with other naming conventions.

Importing the containing module or enum at the same time as items or variants they contain is now done with self instead of mod, as in use foo::{self, bar}

Glob imports are no longer feature-gated.

The box operator and box patterns have been feature-gated pending a redesign. For now unique boxes should be allocated like other containers, with Box::new.

A series of efforts to establish conventions for collections types has resulted in API improvements throughout the standard library.

New APIs for error handling provide ergonomic interop between error types, and new conventions describe more clearly the recommended error handling strategies in Rust.

The fail! macro has been renamed to panic! so that it is easier to discuss failure in the context of error handling without making clarifications as to whether you are referring to the 'fail' macro or failure more generally.

On Linux, OsRng prefers the new, more reliable getrandom syscall when available.

The 'serialize' crate has been renamed 'rustc-serialize' and moved out of the distribution to Cargo. Although it is widely used now, it is expected to be superseded in the near future.

The Show formatter, typically implemented with #[derive(Show)] is now requested with the {:?} specifier and is intended for use by all types, for uses such as println! debugging. The new String formatter must be implemented by hand, uses the {} specifier, and is intended for full-fidelity conversions of things that can logically be represented as strings.

Flexible target specification allows rustc's code generation to be configured to support otherwise-unsupported platforms.

Rust comes with rust-gdb and rust-lldb scripts that launch their respective debuggers with Rust-appropriate pretty-printing.

The Windows installation of Rust is distributed with the MinGW components currently required to link binaries on that platform.

Nullable enum optimizations have been extended to more types so that e.g. Option> and Option<String> take up no more space than the inner types themselves.

Work has begun on supporting AArch64.

The various I/O modules were overhauled to reduce unnecessary abstractions and provide better interoperation with the underlying platform. The old io module remains temporarily at std::old_io.

The standard library now participates in feature gating, so use of unstable libraries now requires a #![feature(...)] attribute. The impact of this change is described on the forum. RFC.

for loops now operate on the IntoIterator trait, which eliminates the need to call .iter(), etc. to iterate over collections. There are some new subtleties to remember though regarding what sort of iterators various types yield, in particular that for foo in bar { } yields values from a move iterator, destroying the original collection. RFC.

Objects now have default lifetime bounds, so you don't have to write Box when you don't care about storing references. RFC.

In types that implement Drop, lifetimes must outlive the value. This will soon make it possible to safely implement Drop for types where #[unsafe_destructor] is now required. Read the gorgeous RFC for details.

The fully qualified ::X syntax lets you set the Self type for a trait method or associated type. RFC.

References to types that implement Deref<U> now automatically coerce to references to the dereferenced type U, e.g. &T where T: Deref<U> automatically coerces to &U. This should eliminate many unsightly uses of &*, as when converting from references to vectors into references to slices. RFC.

The explicit closure kind syntax (|&:|, |&mut:|, |:|) is obsolete and closure kind is inferred from context.

Self is a keyword.

The Show and String formatting traits have been renamed to Debug and Display to more clearly reflect their related purposes. Automatically getting a string conversion to use with format!("{:?}", something_to_debug) is now written #[derive(Debug)].

Abstract OS-specific string types, std::ff::{OsString, OsStr}, provide strings in platform-specific encodings for easier interop with system APIs. RFC.

The boxed::into_raw and Box::from_raw functions convert between Box and *mut T, a common pattern for creating raw pointers.

Certain long error messages of the form 'expected foo found bar' are now split neatly across multiple lines. Examples in the PR.

On Unix Rust can be uninstalled by running /usr/local/lib/rustlib/uninstall.sh.

The #[rustc_on_unimplemented] attribute, requiring the 'on_unimplemented' feature, lets rustc display custom error messages when a trait is expected to be implemented for a type but is not.

Rust is tested against a LALR grammar, which parses almost all the Rust files that rustc does.

The vast majority of the standard library is now #[stable]. It is no longer possible to use unstable features with a stable build of the compiler.

Many popular crates on crates.io now work on the stable release channel.

Arithmetic on basic integer types now checks for overflow in debug builds.

Several restrictions have been added to trait coherence in order to make it easier for upstream authors to change traits without breaking downstream code.

Digits of binary and octal literals are lexed more eagerly to improve error messages and macro behavior. For example, 0b1234 is now lexed as 0b1234 instead of two tokens, 0b1 and 234.

Trait bounds are always invariant, eliminating the need for the PhantomFn and MarkerTrait lang items, which have been removed.

"-" is no longer a valid character in crate names, the extern crate "foo" as bar syntax has been replaced with extern crate foo as bar, and Cargo now automatically translates "-" in package names to underscore for the crate name.

Lifetime shadowing is an error.

Send no longer implies 'static.

UFCS now supports trait-less associated paths like MyType::default().

Primitive types now have inherent methods, obviating the need for extension traits like SliceExt.

Methods with Self: Sized in their where clause are considered object-safe, allowing many extension traits like IteratorExt to be merged into the traits they extended.

You can now refer to associated types whose corresponding trait bounds appear only in a where clause.

The final bits of OIBIT landed, meaning that traits like Send and Sync are now library-defined.

A Reflect trait was introduced, which means that downcasting via the Any trait is effectively limited to concrete types. This helps retain the potentially-important "parametricity" property: generic code cannot behave differently for different type arguments except in minor ways.

The unsafe_destructor feature is now deprecated in favor of the new dropck. This change is a major reduction in unsafe code.

The thread_local module has been renamed to std::thread.

The methods of IteratorExt have been moved to the Iterator trait itself.

Several traits that implement Rust's conventions for type conversions, AsMut, AsRef, From, and Into have been centralized in the std::convert module.

The FromError trait was removed in favor of From.

The basic sleep function has moved to std::thread::sleep_ms.

The splitn function now takes an n parameter that represents the number of items yielded by the returned iterator instead of the number of 'splits'.

On Unix, all file descriptors are CLOEXEC by default.

Derived implementations of PartialOrd now order enums according to their explicitly-assigned discriminants.

Methods for searching strings are generic over Patterns, implemented presently by &char, &str, FnMut(char) -> bool and some others.

In method resolution, object methods are resolved before inherent methods.

String::from_str has been deprecated in favor of the From impl, String::from.

io::Error implements Sync.

The words method on &str has been replaced with split_whitespace, to avoid answering the tricky question, 'what is a word?'

The new path and IO modules are complete and #[stable]. This was the major library focus for this cycle.

The path API was revised to normalize ., adjusting the tradeoffs in favor of the most common usage.

A large number of remaining APIs in std were also stabilized during this cycle; about 75% of the non-deprecated API surface is now stable.

The new string pattern API landed, which makes the string slice API much more internally consistent and flexible.

A new set of generic conversion traits replaced many existing ad hoc traits.

Generic numeric traits were completely removed. This was made possible thanks to inherent methods for primitive types, and the removal gives maximal flexibility for designing a numeric hierarchy in the future.

The Fn traits are now related via inheritance and provide ergonomic blanket implementations.

The Index and IndexMut traits were changed to take the index by value, enabling code like hash_map["string"] to work.

Copy now inherits from Clone, meaning that all Copy data is known to be Clone as well.

Many errors now have extended explanations that can be accessed with the --explain flag to rustc.

Many new examples have been added to the standard library documentation.

rustdoc has received a number of improvements focused on completion and polish.

Metadata was tuned, shrinking binaries by 27%.

Much headway was made on ecosystem-wide CI, making it possible to compare builds for breakage.

The std::fs module has been expanded to expand the set of functionality exposed:

• DirEntry now supports optimizations like file_type and metadata which don't incur a syscall on some platforms.

• A symlink_metadata function has been added.

• The fs::Metadata structure now lowers to its OS counterpart, providing access to all underlying information.

The compiler now contains extended explanations of many errors. When an error with an explanation occurs the compiler suggests using the --explain flag to read the explanation. Error explanations are also available online.

Thanks to multiple improvements to type checking, as well as other work, the time to bootstrap the compiler decreased by 32%.

The str::split_whitespace method splits a string on unicode whitespace boundaries.

On both Windows and Unix, new extension traits provide conversion of I/O types to and from the underlying system handles. On Unix, these traits are FromRawFd and AsRawFd, on Windows FromRawHandle and AsRawHandle. These are implemented for File, TcpStream, TcpListener, and UpdSocket. Further implementations for std::process will be stabilized later.

On Unix, std::os::unix::symlink creates symlinks. On Windows, symlinks can be created with std::os::windows::symlink_dir and std::os::windows::symlink_file.

The mpsc::Receiver type can now be converted into an iterator with into_iter on the IntoIterator trait.

Ipv4Addr can be created from u32 with the From<u32> implementation of the From trait.

The Debug implementation for RangeFull creates output that is more consistent with other implementations.

Debug is implemented for File.

The Default implementation for Arc no longer requires Sync + Send.

The Iterator methods count, nth, and last have been overridden for slices to have O(1) performance instead of O(n).

Incorrect handling of paths on Windows has been improved in both the compiler and the standard library.

AtomicPtr gained a Default implementation.

In accordance with Rust's policy on arithmetic overflow abs now panics on overflow when debug assertions are enabled.

The Cloned iterator, which was accidentally left unstable for 1.0 has been stabilized.

The Incoming iterator, which iterates over incoming TCP connections, and which was accidentally unnamable in 1.0, is now properly exported.

BinaryHeap no longer corrupts itself when functions called by sift_up or sift_down panic.

The split_off method of LinkedList no longer corrupts the list in certain scenarios.

Type checking performance has improved notably with multiple improvements.

The compiler suggests code changes for more errors.

rustc and it's build system have experimental support for building toolchains against MUSL instead of glibc on Linux.

The compiler defines the target_env cfg value, which is used for distinguishing toolchains that are otherwise for the same platform. Presently this is set to gnu for common GNU Linux targets and for MinGW targets, and musl for MUSL Linux targets.

The cargo rustc command invokes a build with custom flags to rustc.

Android executables are always position independent.

The drop_with_repr_extern lint warns about mixing repr(C) with Drop.

Dynamically-sized-type coercions allow smart pointer types like Rc to contain types without a fixed size, arrays and trait objects, finally enabling use of Rc<[T]> and completing the implementation of DST.

Parallel codegen is now working again, which can substantially speed up large builds in debug mode; It also gets another ~33% speedup when bootstrapping on a 4 core machine (using 8 jobs). It's not enabled by default, but will be "in the near future". It can be activated with the -C codegen-units=N flag to rustc.

This is the first release with experimental support for linking with the MSVC linker and lib C on Windows (instead of using the GNU variants via MinGW). It is yet recommended only for the most intrepid Rustaceans.

Benchmark compilations are showing a 30% improvement in bootstrapping over 1.1.

The to_uppercase and to_lowercase methods on char now do unicode case mapping, which is a previously-planned change in behavior and considered a bugfix.

mem::align_of now specifies the minimum alignment for T, which is usually the alignment programs are interested in, and the same value reported by clang's alignof. mem::min_align_of is deprecated. This is not known to break real code.

The #[packed] attribute is no longer silently accepted by the compiler. This attribute did nothing and code that mentioned it likely did not work as intended.

Associated type defaults are now behind the associated_type_defaults feature gate. In 1.1 associated type defaults did not work, but could be mentioned syntactically. As such this breakage has minimal impact.

Patterns with ref mut now correctly invoke DerefMut when matching against dereferenceable values.

The Extend trait, which grows a collection from an iterator, is implemented over iterators of references, for String, Vec, LinkedList, VecDeque, EnumSet, BinaryHeap, VecMap, BTreeSet and BTreeMap. RFC.

The iter::once function returns an iterator that yields a single element, and iter::empty returns an iterator that yields no elements.

The matches and rmatches methods on str return iterators over substring matches.

Cell and RefCell both implement Eq.

A number of methods for wrapping arithmetic are added to the integral types, wrapping_div, wrapping_rem, wrapping_neg, wrapping_shl, wrapping_shr. These are in addition to the existing wrapping_add, wrapping_sub, and wrapping_mul methods, and alternatives to the Wrapping type.. It is illegal for the default arithmetic operations in Rust to overflow; the desire to wrap must be explicit.

The {:#?} formatting specifier displays the alternate, pretty-printed form of the Debug formatter. This feature was actually introduced prior to 1.0 with little fanfare.

fmt::Formatter implements fmt::Write, a fmt-specific trait for writing data to formatted strings, similar to io::Write.

fmt::Formatter adds 'debug builder' methods, debug_struct, debug_tuple, debug_list, debug_set, debug_map. These are used by code generators to emit implementations of Debug.

str has new to_uppercase and to_lowercase methods that convert case, following Unicode case mapping.

It is now easier to handle poisoned locks. The PoisonError type, returned by failing lock operations, exposes into_inner, get_ref, and get_mut, which all give access to the inner lock guard, and allow the poisoned lock to continue to operate. The is_poisoned method of RwLock and Mutex can poll for a poisoned lock without attempting to take the lock.

On Unix the FromRawFd trait is implemented for Stdio, and AsRawFd for ChildStdin, ChildStdout, ChildStderr. On Windows the FromRawHandle trait is implemented for Stdio, and AsRawHandle for ChildStdin, ChildStdout, ChildStderr.

io::ErrorKind has a new variant, InvalidData, which indicates malformed input.

rustc employs smarter heuristics for guessing at typos.

rustc emits more efficient code for no-op conversions between unsafe pointers.

Fat pointers are now passed in pairs of immediate arguments, resulting in faster compile times and smaller code.

The new object lifetime defaults have been turned on after a cycle of warnings about the change. Now types like &'a Box (or &'a Rc, etc) will change from being interpreted as &'a Box to &'a Box.

The Rustonomicon is a new book in the official documentation that dives into writing unsafe Rust.

The Duration API, has been stabilized. This basic unit of timekeeping is employed by other std APIs, as well as out-of-tree time crates.

The new object lifetime defaults have been turned on after a cycle of warnings about the change.

There is a known regression in how object lifetime elision is interpreted, the proper solution for which is undetermined.

The #[prelude_import] attribute, an internal implementation detail, was accidentally stabilized previously. It has been put behind the prelude_import feature gate. This change is believed to break no existing code.

The behavior of size_of_val and align_of_val is more sane for dynamically sized types. Code that relied on the previous behavior is thought to be broken.

The dropck rules, which checks that destructors can't access destroyed values, have been updated to match the RFC. This fixes some soundness holes, and as such will cause some previously-compiling code to no longer build.

The new object lifetime defaults have been turned on after a cycle of warnings about the change.

Semicolons may now follow types and paths in macros.

The behavior of size_of_val and align_of_val is more sane for dynamically sized types. Code that relied on the previous behavior is not known to exist, and suspected to be broken.

'static variables may now be recursive.

ref bindings choose between Deref and DerefMut implementations correctly.

The dropck rules, which checks that destructors can't access destroyed values, have been updated to match the RFC.

The Duration API, has been stabilized, as well as the std::time module, which presently contains only Duration.

Box<str> and Box<[T]> both implement Clone.

The owned C string, CString, implements Borrow and the borrowed C string, CStr, implements ToOwned. The two of these allow C strings to be borrowed and cloned in generic code.

CStr implements Debug.

AtomicPtr implements Debug.

Error trait objects can be downcast to their concrete types in many common configurations, using the is, downcast, downcast_ref and downcast_mut methods, similarly to the Any trait.

Searching for substrings now employs the two-way algorithm instead of doing a naive search. This gives major speedups to a number of methods, including contains, find, rfind, split. starts_with and ends_with are also faster.

The performance of PartialEq for slices is much faster.

The Hash trait offers the default method, hash_slice, which is overridden and optimized by the implementations for scalars.

The Hasher trait now has a number of specialized write_* methods for primitive types, for efficiency.

The I/O-specific error type, std::io::Error, gained a set of methods for accessing the 'inner error', if any: get_ref, get_mut, into_inner. As well, the implementation of std::error::Error::cause also delegates to the inner error.

process::Child gained the id method, which returns a u32 representing the platform-specific process identifier.

The connect method on slices is deprecated, replaced by the new join method (note that both of these are on the unstable SliceConcatExt trait, but through the magic of the prelude are available to stable code anyway).

The Div operator is implemented for Wrapping types.

DerefMut is implemented for String.

Performance of SipHash (the default hasher for HashMap) is better for long data.

AtomicPtr implements Send.

The read_to_end implementations for Stdin and File are now specialized to use uninitialized buffers for increased performance.

Lifetime parameters of foreign functions are now resolved properly.

Rust can now, with some coercion, produce programs that run on Windows XP, though XP is not considered a supported platform.

Porting Rust on Windows from the GNU toolchain to MSVC continues (1, 2, 3, 4). It is still not recommended for use in 1.3, though should be fully-functional in the 64-bit 1.4 beta.

On Fedora-based systems installation will properly configure the dynamic linker.

The compiler gained many new extended error descriptions, which can be accessed with the --explain flag.

The dropck pass, which checks that destructors can't access destroyed values, has been rewritten. This fixes some soundness holes, and as such will cause some previously-compiling code to no longer build.

rustc now uses LLVM to write archive files where possible. Eventually this will eliminate the compiler's dependency on the ar utility.

Rust has preliminary support for i686 FreeBSD (it has long supported FreeBSD on x86_64).

The unused_mut, unconditional_recursion, improper_ctypes, and negate_unsigned lints are more strict.

If landing pads are disabled (with -Z no-landing-pads), panic! will kill the process instead of leaking.

Windows builds targeting the 64-bit MSVC ABI and linker (instead of GNU) are now supported and recommended for use.

Several changes have been made to fix type soundness and improve the behavior of associated types. See RFC 1214. Although we have mostly introduced these changes as warnings this release, to become errors next release, there are still some scenarios that will see immediate breakage.

The str::lines and BufRead::lines iterators treat \r\n as line breaks in addition to \n.

Loans of 'static lifetime extend to the end of a function.

str::parse no longer introduces avoidable rounding error when parsing floating point numbers. Together with earlier changes to float formatting/output, "round trips" like f.to_string().parse() now preserve the value of f exactly. Additionally, leading plus signs are now accepted.

use statements that import multiple items can now rename them, as in use foo::{bar as kitten, baz as puppy}.

Binops work correctly on fat pointers.

pub extern crate, which does not behave as expected, issues a warning until a better solution is found.

Many APIs were stabilized: <Box<str>>::into_string, Arc::downgrade, Arc::get_mut, Arc::make_mut, Arc::try_unwrap, Box::from_raw, Box::into_raw, CStr::to_str, CStr::to_string_lossy, CString::from_raw, CString::into_raw, IntoRawFd::into_raw_fd, IntoRawFd, IntoRawHandle::into_raw_handle, IntoRawHandle, IntoRawSocket::into_raw_socket, IntoRawSocket, Rc::downgrade, Rc::get_mut, Rc::make_mut, Rc::try_unwrap, Result::expect, String::into_boxed_str, TcpStream::read_timeout, TcpStream::set_read_timeout, TcpStream::set_write_timeout, TcpStream::write_timeout, UdpSocket::read_timeout, UdpSocket::set_read_timeout, UdpSocket::set_write_timeout, UdpSocket::write_timeout, Vec::append, Vec::split_off, VecDeque::append, VecDeque::retain, VecDeque::split_off, rc::Weak::upgrade, rc::Weak, slice::Iter::as_slice, slice::IterMut::into_slice, str::CharIndices::as_str, str::Chars::as_str, str::split_at_mut, str::split_at, sync::Weak::upgrade, sync::Weak, thread::park_timeout, thread::sleep.

Some APIs were deprecated: BTreeMap::with_b, BTreeSet::with_b, Option::as_mut_slice, Option::as_slice, Result::as_mut_slice, Result::as_slice, f32::from_str_radix, f64::from_str_radix.

Reverse-searching strings is faster with the 'two-way' algorithm.

std::io::copy allows ?Sized arguments.

The Windows, Chunks, and ChunksMut iterators over slices all override count, nth and last with an O(1) implementation.

Default is implemented for arrays up to [T; 32].

IntoRawFd has been added to the Unix-specific prelude, IntoRawSocket and IntoRawHandle to the Windows-specific prelude.

Extend<String> and FromIterator<String are both implemented for String.

IntoIterator is implemented for references to Option and Result.

HashMap and HashSet implement Extend<&T> where T: Copy as part of RFC 839. This will cause type inference breakage in rare situations.

BinaryHeap implements Debug.

Borrow and BorrowMut are implemented for fixed-size arrays.

extern fns with the "Rust" and "C" ABIs implement common traits including Eq, Ord, Debug, Hash.

String comparison is faster.

&mut T where T: std::fmt::Write also implements std::fmt::Write.

A stable regression in VecDeque::push_back and other capacity-altering methods that caused panics for zero-sized types was fixed.

Function pointers implement traits for up to 12 parameters.

The compiler no longer uses the 'morestack' feature to prevent stack overflow. Instead it uses guard pages and stack probes (though stack probes are not yet implemented on any platform but Windows).

The compiler matches traits faster when projections are involved.

The 'improper_ctypes' lint no longer warns about use of isize and usize.

Cargo now displays useful information about what its doing during cargo update.

Stabilized APIs: BinaryHeap::from, BinaryHeap::into_sorted_vec, BinaryHeap::into_vec, Condvar::wait_timeout, FileTypeExt::is_block_device, FileTypeExt::is_char_device, FileTypeExt::is_fifo, FileTypeExt::is_socket, FileTypeExt, Formatter::alternate, Formatter::fill, Formatter::precision, Formatter::sign_aware_zero_pad, Formatter::sign_minus, Formatter::sign_plus, Formatter::width, Iterator::cmp, Iterator::eq, Iterator::ge, Iterator::gt, Iterator::le, Iterator::lt, Iterator::ne, Iterator::partial_cmp, Path::canonicalize, Path::exists, Path::is_dir, Path::is_file, Path::metadata, Path::read_dir, Path::read_link, Path::symlink_metadata, Utf8Error::valid_up_to, Vec::resize, VecDeque::as_mut_slices, VecDeque::as_slices, VecDeque::insert, VecDeque::shrink_to_fit, VecDeque::swap_remove_back, VecDeque::swap_remove_front, slice::split_first_mut, slice::split_first, slice::split_last_mut, slice::split_last, char::from_u32_unchecked, fs::canonicalize, str::MatchIndices, str::RMatchIndices, str::match_indices, str::rmatch_indices, str::slice_mut_unchecked, string::ParseError.

Rust applications hosted on crates.io can be installed locally to ~/.cargo/bin with the cargo install command. Among other things this makes it easier to augment Cargo with new subcommands: when a binary named e.g. cargo-foo is found in $PATH it can be invoked as cargo foo.

Crates with wildcard (*) dependencies will emit warnings when published. In 1.6 it will no longer be possible to publish crates with wildcard dependencies.

The rules determining when a particular lifetime must outlive a particular value (known as 'dropck') have been modified to not rely on parametricity.

Implementations of AsRef and AsMut were added to Box, Rc, and Arc. Because these smart pointer types implement Deref, this causes breakage in cases where the interior type contains methods of the same name.

Correct a bug in Rc/Arc that caused dropck to be unaware that they could drop their content. Soundness fix.

All method invocations are properly checked for well-formedness. Soundness fix.

Traits whose supertraits contain Self are not object safe. Soundness fix.

Target specifications support a no_default_libraries setting that controls whether -nodefaultlibs is passed to the linker, and in turn the is_like_windows setting no longer affects the -nodefaultlibs flag.

#[derive(Show)], long-deprecated, has been removed.

The #[inline] and #[repr] attributes can only appear in valid locations.

Native libraries linked from the local crate are passed to the linker before native libraries from upstream crates.

Two rarely-used attributes, #[no_debug] and #[omit_gdb_pretty_printer_section] are feature gated.

Negation of unsigned integers, which has been a warning for several releases, is now behind a feature gate and will generate errors.

The parser accidentally accepted visibility modifiers on enum variants, a bug which has been fixed.

A bug was fixed that allowed use statements to import unstable features.

When evaluating expressions at compile-time that are not compile-time constants (const-evaluating expressions in non-const contexts), incorrect code such as overlong bitshifts and arithmetic overflow will generate a warning instead of an error, delaying the error until runtime. This will allow the const-evaluator to be expanded in the future backwards-compatibly.

The improper_ctypes lint no longer warns about using isize and usize in FFI.

Arc and Rc are covariant with respect to T instead of invariant.

Default is implemented for mutable slices.

FromStr is implemented for SockAddrV4 and SockAddrV6.

There are now From conversions between floating point types where the conversions are lossless.

There are now From conversions between integer types where the conversions are lossless.

fs::Metadata implements Clone.

The parse method accepts a leading "+" when parsing integers.

AsMut is implemented for Vec.

The clone_from implementations for String and BinaryHeap have been optimized and no longer rely on the default impl.

The extern "Rust", extern "C", unsafe extern "Rust" and unsafe extern "C" function types now implement Clone, PartialEq, Eq, PartialOrd, Ord, Hash, fmt::Pointer, and fmt::Debug for up to 12 arguments.

Dropping Vecs is much faster in unoptimized builds when the element types don't implement Drop.

A bug that caused in incorrect behavior when combining VecDeque with zero-sized types was resolved.

PartialOrd for slices is faster.

Crate metadata size was reduced by 20%.

Improvements to code generation reduced the size of libcore by 3.3 MB and rustc's memory usage by 18MB.

Improvements to deref translation increased performance in unoptimized builds.

Various errors in trait resolution are deduplicated to only be reported once.

Rust has preliminary support for rumprun kernels.

Rust has preliminary support for NetBSD on amd64.

The #![no_std] attribute causes a crate to not be linked to the standard library, but only the core library, as described in RFC 1184. The core library defines common types and traits but has no platform dependencies whatsoever, and is the basis for Rust software in environments that cannot support a full port of the standard library, such as operating systems. Most of the core library is now stable.

Stabilized APIs: Read::read_exact, ErrorKind::UnexpectedEof (renamed from UnexpectedEOF), fs::DirBuilder, fs::DirBuilder::new, fs::DirBuilder::recursive, fs::DirBuilder::create, os::unix::fs::DirBuilderExt, os::unix::fs::DirBuilderExt::mode, vec::Drain, vec::Vec::drain, string::Drain, string::String::drain, vec_deque::Drain, vec_deque::VecDeque::drain, collections::hash_map::Drain, collections::hash_map::HashMap::drain, collections::hash_set::Drain, collections::hash_set::HashSet::drain, collections::binary_heap::Drain, collections::binary_heap::BinaryHeap::drain, Vec::extend_from_slice (renamed from push_all), Mutex::get_mut, Mutex::into_inner, RwLock::get_mut, RwLock::into_inner, Iterator::min_by_key (renamed from min_by), Iterator::max_by_key (renamed from max_by).

The core library is stable, as are most of its APIs.

The assert_eq! macro supports arguments that don't implement Sized, such as arrays. In this way it behaves more like assert!.

Several timer functions that take duration in milliseconds are deprecated in favor of those that take Duration. These include Condvar::wait_timeout_ms, thread::sleep_ms, and thread::park_timeout_ms.

The algorithm by which Vec reserves additional elements was tweaked to not allocate excessive space while still growing exponentially.

From conversions are implemented from integers to floats in cases where the conversion is lossless. Thus they are not implemented for 32-bit ints to f32, nor for 64-bit ints to f32 or f64. They are also not implemented for isize and usize because the implementations would be platform-specific. From is also implemented from f32 to f64.

From<&Path> and From<PathBuf> are implemented for Cow<Path>.

From is implemented for Box, Rc and Arc.

IntoIterator is implemented for &PathBuf and &Path.

BinaryHeap was refactored for modest performance improvements.

Sorting slices that are already sorted is 50% faster in some cases.

Cargo will look in $CARGO_HOME/bin for subcommands by default.

Cargo build scripts can specify their dependencies by emitting the rerun-if-changed key.

crates.io will reject publication of crates with dependencies that have a wildcard version constraint. Crates with wildcard dependencies were seen to cause a variety of problems, as described in RFC 1241. Since 1.5 publication of such crates has emitted a warning.

cargo clean accepts a --release flag to clean the release folder. A variety of artifacts that Cargo failed to clean are now correctly deleted.

The unreachable_code lint warns when a function call's argument diverges.

The parser indicates failures that may be caused by confusingly-similar Unicode characters

Certain macro errors are reported at definition time, not expansion.

The compiler no longer makes use of the RUST_PATH environment variable when locating crates. This was a pre-cargo feature for integrating with the package manager that was accidentally never removed.

A number of bugs were fixed in the privacy checker that could cause previously-accepted code to break.

Modules and unit/tuple structs may not share the same name.

Bugs in pattern matching unit structs were fixed. The tuple struct pattern syntax (Foo(..)) can no longer be used to match unit structs. This is a warning now, but will become an error in future releases. Patterns that share the same name as a const are now an error.

A bug was fixed that causes rustc not to apply default type parameters when resolving certain method implementations of traits defined in other crates.

Stabilized APIs

• Path

  • Path::strip_prefix (renamed from relative_from)

  • path::StripPrefixError (new error type returned from strip_prefix)

• Ipv4Addr

  • Ipv4Addr::is_loopback

  • Ipv4Addr::is_private

  • Ipv4Addr::is_link_local

  • Ipv4Addr::is_multicast

  • Ipv4Addr::is_broadcast

  • Ipv4Addr::is_documentation

• Ipv6Addr

  • Ipv6Addr::is_unspecified

  • Ipv6Addr::is_loopback

  • Ipv6Addr::is_multicast

• Vec

  • Vec::as_slice

  • Vec::as_mut_slice

• String

  • String::as_str

  • String::as_mut_str

• Slices

  • <[T]>::clone_from_slice, which now requires the two slices to be the same length

  • <[T]>::sort_by_key

• checked, saturated, and overflowing operations

  • i32::checked_rem, i32::checked_neg, i32::checked_shl, i32::checked_shr

  • i32::saturating_mul

  • i32::overflowing_add, i32::overflowing_sub, i32::overflowing_mul, i32::overflowing_div

  • i32::overflowing_rem, i32::overflowing_neg, i32::overflowing_shl, i32::overflowing_shr

  • u32::checked_rem, u32::checked_neg, u32::checked_shl, u32::checked_shl

  • u32::saturating_mul

  • u32::overflowing_add, u32::overflowing_sub, u32::overflowing_mul, u32::overflowing_div

  • u32::overflowing_rem, u32::overflowing_neg, u32::overflowing_shl, u32::overflowing_shr

  • and checked, saturated, and overflowing operations for other primitive types

• FFI

  • ffi::IntoStringError

  • CString::into_string

  • CString::into_bytes

  • CString::into_bytes_with_nul

  • From for Vec<u8>

• IntoStringError

  • IntoStringError::into_cstring

  • IntoStringError::utf8_error

  • Error for IntoStringError

• Hashing

  • std::hash::BuildHasher

  • BuildHasher::Hasher

  • BuildHasher::build_hasher

  • std::hash::BuildHasherDefault

  • HashMap::with_hasher

  • HashMap::with_capacity_and_hasher

  • HashSet::with_hasher

  • HashSet::with_capacity_and_hasher

  • std::collections::hash_map::RandomState

  • RandomState::new

Validating UTF-8 is faster by a factor of between 7 and 14x for ASCII input. This means that creating Strings and strs from bytes is faster.

The performance of LineWriter (and thus io::stdout) was improved by using memchr to search for newlines.

f32::to_degrees and f32::to_radians are stable. The f64 variants were stabilized previously.

BTreeMap was rewritten to use less memory and improve the performance of insertion and iteration, the latter by as much as 5x.

BTreeSet and its iterators, Iter, IntoIter, and Range are covariant over their contained type.

LinkedList and its iterators, Iter and IntoIter are covariant over their contained type.

str::replace now accepts a Pattern, like other string searching methods.

Any is implemented for unsized types.

Hash is implemented for Duration.

When running tests with --test, rustdoc will pass --cfg arguments to the compiler.

The compiler is built with RPATH information by default. This means that it will be possible to run rustc when installed in unusual configurations without configuring the dynamic linker search path explicitly.

rustc passes --enable-new-dtags to GNU ld. This makes any RPATH entries (emitted with -C rpath) not take precedence over LD_LIBRARY_PATH.

cargo rustc accepts a --profile flag that runs rustc under any of the compilation profiles, 'dev', 'bench', or 'test'.

The rerun-if-changed build script directive no longer causes the build script to incorrectly run twice in certain scenarios.

Soundness fixes to the interactions between associated types and lifetimes, specified in RFC 1214, now generate errors for code that violates the new rules. This is a significant change that is known to break existing code, so it has emitted warnings for the new error cases since 1.4 to give crate authors time to adapt. The details of what is changing are subtle; read the RFC for more.

Several bugs in the compiler's visibility calculations were fixed. Since this was found to break significant amounts of code, the new errors will be emitted as warnings for several release cycles, under the private_in_public lint.

Defaulted type parameters were accidentally accepted in positions that were not intended. In this release, defaulted type parameters appearing outside of type definitions will generate a warning, which will become an error in future releases.

Parsing "." as a float results in an error instead of 0. That is, ".".parse::() returns Err, not Ok(0.0).

Borrows of closure parameters may not outlive the closure.

Rust supports overloading of compound assignment statements like += by implementing the AddAssign, SubAssign, MulAssign, DivAssign, RemAssign, BitAndAssign, BitOrAssign, BitXorAssign, ShlAssign, or ShrAssign traits. RFC 953.

Empty structs can be defined with braces, as in struct Foo { }, in addition to the non-braced form, struct Foo;. RFC 218.

Stabilized APIs:

• str::encode_utf16 (renamed from utf16_units)

• str::EncodeUtf16 (renamed from Utf16Units)

• Ref::map

• RefMut::map

• ptr::drop_in_place

• time::Instant

• time::SystemTime

• Instant::now

• Instant::duration_since (renamed from duration_from_earlier)

• Instant::elapsed

• SystemTime::now

• SystemTime::duration_since (renamed from duration_from_earlier)

• SystemTime::elapsed

• Various Add/Sub impls for Time and SystemTime

• SystemTimeError

• SystemTimeError::duration

• Various impls for SystemTimeError

• UNIX_EPOCH

• AddAssign, SubAssign, MulAssign, DivAssign, RemAssign, BitAndAssign, BitOrAssign, BitXorAssign, ShlAssign, ShrAssign.

The write! and writeln! macros correctly emit errors if any of their arguments can't be formatted.

Various I/O functions support large files on 32-bit Linux.

The Unix-specific raw modules, which contain a number of redefined C types are deprecated, including os::raw::unix, os::raw::macos, and os::raw::linux. These modules defined types such as ino_t and dev_t. The inconsistency of these definitions across platforms was making it difficult to implement std correctly. Those that need these definitions should use the libc crate. RFC 1415.

The Unix-specific MetadataExt traits, including os::unix::fs::MetadataExt, which expose values such as inode numbers no longer return platform-specific types, but instead return widened integers. RFC 1415.

btree_set::{IntoIter, Iter, Range} are covariant.

Atomic loads and stores are not volatile.

All types in sync::mpsc implement fmt::Debug.

Inlining hash functions lead to a 3% compile-time improvement in some workloads.

When using jemalloc, its symbols are unprefixed so that it overrides the libc malloc implementation. This means that for rustc, LLVM is now using jemalloc, which results in a 6% compile-time improvement on a specific workload.

Avoid quadratic growth in function size due to cleanups.

32-bit MSVC builds finally implement unwinding. i686-pc-windows-msvc is now considered a tier-1 platform.

The --print targets flag prints a list of supported targets.

The --print cfg flag prints the cfgs defined for the current target.

rustc can be built with an new Cargo-based build system, written in Rust. It will eventually replace Rust's Makefile-based build system. To enable it configure with configure --rustbuild.

Errors for non-exhaustive match patterns now list up to 3 missing variants while also indicating the total number of missing variants if more than 3.

Executable stacks are disabled on Linux and BSD.

The Rust Project now publishes binary releases of the standard library for a number of tier-2 targets: armv7-unknown-linux-gnueabihf, powerpc-unknown-linux-gnu, powerpc64-unknown-linux-gnu, powerpc64le-unknown-linux-gnu x86_64-rumprun-netbsd. These can be installed with tools such as multirust.

cargo init creates a new Cargo project in the current directory. It is otherwise like cargo new.

Cargo has configuration keys for -v and --color. verbose and color, respectively, go in the [term] section of .cargo/config.

Configuration keys that evaluate to strings or integers can be set via environment variables. For example the build.jobs key can be set via CARGO_BUILD_JOBS. Environment variables take precedence over config files.

Target-specific dependencies support Rust cfg syntax for describing targets so that dependencies for multiple targets can be specified together. RFC 1361.

The environment variables CARGO_TARGET_ROOT, RUSTC, and RUSTDOC take precedence over the build.target-dir, build.rustc, and build.rustdoc configuration values.

The child process tree is killed on Windows when Cargo is killed.

The build.target configuration value sets the target platform, like --target.

Unstable compiler flags have been further restricted. Since 1.0 -Z flags have been considered unstable, and other flags that were considered unstable additionally required passing -Z unstable-options to access. Unlike unstable language and library features though, these options have been accessible on the stable release channel. Going forward, new unstable flags will not be available on the stable release channel, and old unstable flags will warn about their usage. In the future, all unstable flags will be unavailable on the stable release channel.

It is no longer possible to match on empty enum variants using the Variant(..) syntax. This has been a warning since 1.6.

The Unix-specific MetadataExt traits, including os::unix::fs::MetadataExt, which expose values such as inode numbers no longer return platform-specific types, but instead return widened integers. RFC 1415.

Modules sourced from the filesystem cannot appear within arbitrary blocks, but only within other modules.

--cfg compiler flags are parsed strictly as identifiers.

On Unix, stack overflow triggers a runtime abort instead of a SIGSEGV.

Command::spawn and its equivalents return an error if any of its command-line arguments contain interior NULs.

Tuple and unit enum variants from other crates are in the type namespace.

On Windows rustc emits .lib files for the staticlib library type instead of .a files. Additionally, for the MSVC toolchain, rustc emits import libraries named foo.dll.lib instead of foo.lib.

The #[deprecated] attribute when applied to an API will generate warnings when used. The warnings may be suppressed with #[allow(deprecated)]. RFC 1270.

fn item types are zero sized, and each fn names a unique type. This will break code that transmutes fns, so calling transmute on a fn type will generate a warning for a few cycles, then will be converted to an error.

Field and method resolution understand visibility, so private fields and methods cannot prevent the proper use of public fields and methods.

The parser considers unicode codepoints in the PATTERN_WHITE_SPACE category to be whitespace.

std::panic

std::panic::catch_unwind (renamed from recover)

std::panic::resume_unwind (renamed from propagate)

std::panic::AssertUnwindSafe (renamed from AssertRecoverSafe)

std::panic::UnwindSafe (renamed from RecoverSafe)

str::is_char_boundary

<*const T>::as_ref

<*mut T>::as_ref

<*mut T>::as_mut

AsciiExt::make_ascii_uppercase

AsciiExt::make_ascii_lowercase

char::decode_utf16

char::DecodeUtf16

char::DecodeUtf16Error

char::DecodeUtf16Error::unpaired_surrogate

BTreeSet::take

BTreeSet::replace

BTreeSet::get

HashSet::take

HashSet::replace

HashSet::get

OsString::with_capacity

OsString::clear

OsString::capacity

OsString::reserve

OsString::reserve_exact

OsStr::is_empty

OsStr::len

std::os::unix::thread

RawPthread

JoinHandleExt

JoinHandleExt::as_pthread_t

JoinHandleExt::into_pthread_t

HashSet::hasher

HashMap::hasher

CommandExt::exec

File::try_clone

SocketAddr::set_ip

SocketAddr::set_port

SocketAddrV4::set_ip

SocketAddrV4::set_port

SocketAddrV6::set_ip

SocketAddrV6::set_port

SocketAddrV6::set_flowinfo

SocketAddrV6::set_scope_id

slice::copy_from_slice

ptr::read_volatile

ptr::write_volatile

OpenOptions::create_new

TcpStream::set_nodelay

TcpStream::nodelay

TcpStream::set_ttl

TcpStream::ttl

TcpStream::set_only_v6

TcpStream::only_v6

TcpStream::take_error

TcpStream::set_nonblocking

TcpListener::set_ttl

TcpListener::ttl

TcpListener::set_only_v6

TcpListener::only_v6

TcpListener::take_error

TcpListener::set_nonblocking

UdpSocket::set_broadcast

UdpSocket::broadcast

UdpSocket::set_multicast_loop_v4

UdpSocket::multicast_loop_v4

UdpSocket::set_multicast_ttl_v4

UdpSocket::multicast_ttl_v4

UdpSocket::set_multicast_loop_v6

UdpSocket::multicast_loop_v6

UdpSocket::set_multicast_ttl_v6

UdpSocket::multicast_ttl_v6

UdpSocket::set_ttl

UdpSocket::ttl

UdpSocket::set_only_v6

UdpSocket::only_v6

UdpSocket::join_multicast_v4

UdpSocket::join_multicast_v6

UdpSocket::leave_multicast_v4

UdpSocket::leave_multicast_v6

UdpSocket::take_error

UdpSocket::connect

UdpSocket::send

UdpSocket::recv

UdpSocket::set_nonblocking

std::sync::Once is poisoned if its initialization function fails.

cell::Ref and cell::RefMut can contain unsized types.

Most types implement fmt::Debug.

The default buffer size used by BufReader and BufWriter was reduced to 8K, from 64K. This is in line with the buffer size used by other languages.

Instant, SystemTime and Duration implement += and -=. Duration additionally implements *= and /=.

Skip is a DoubleEndedIterator.

From<[u8; 4]> is implemented for Ipv4Addr.

Chain implements BufRead.

HashMap, HashSet and iterators are covariant.

Cargo can now run concurrently.

Top-level overrides allow specific revisions of crates to be overridden through the entire crate graph. This is intended to make upgrades easier for large projects, by allowing crates to be forked temporarily until they've been upgraded and republished.

Cargo exports a CARGO_PKG_AUTHORS environment variable.

Cargo will pass the contents of the RUSTFLAGS variable to rustc on the commandline. rustc arguments can also be specified in the build.rustflags configuration key.

The time complexity of comparing variables for equivalence during type unification is reduced from O(n!) to O(n). This leads to major compilation time improvement in some scenarios.

ToString is specialized for str, giving it the same performance as to_owned.

Spawning processes with Command::output no longer creates extra threads.

#[derive(PartialEq)] and #[derive(PartialOrd)] emit less code for C-like enums.

Passing the --quiet flag to a test runner will produce much-abbreviated output.

The Rust Project now publishes std binaries for the mips-unknown-linux-musl, mipsel-unknown-linux-musl, and i586-pc-windows-msvc targets.

std::sync::Once is poisoned if its initialization function fails.

It is illegal to define methods with the same name in overlapping inherent impl blocks.

fn item types are zero sized, and each fn names a unique type. This will break code that transmutes fns, so calling transmute on a fn type will generate a warning for a few cycles, then will be converted to an error.

Improvements to const evaluation may trigger new errors when integer literals are out of range.

Copy types are required to have a trivial implementation of Clone. RFC 1521.

Single-variant enums support the #[repr(..)] attribute.

Fix #[derive(RustcEncodable)] in the presence of other encode methods.

panic! can be converted to a runtime abort with the -C panic=abort flag. RFC 1513.

Add a new crate type, 'cdylib'. cdylibs are dynamic libraries suitable for loading by non-Rust hosts. RFC 1510. Note that Cargo does not yet directly support cdylibs.

os::windows::fs::OpenOptionsExt::access_mode

os::windows::fs::OpenOptionsExt::share_mode

os::windows::fs::OpenOptionsExt::custom_flags

os::windows::fs::OpenOptionsExt::attributes

os::windows::fs::OpenOptionsExt::security_qos_flags

os::unix::fs::OpenOptionsExt::custom_flags

sync::Weak::new

Default for sync::Weak

panic::set_hook

panic::take_hook

panic::PanicInfo

panic::PanicInfo::payload

panic::PanicInfo::location

panic::Location

panic::Location::file

panic::Location::line

ffi::CStr::from_bytes_with_nul

ffi::CStr::from_bytes_with_nul_unchecked

ffi::FromBytesWithNulError

fs::Metadata::modified

fs::Metadata::accessed

fs::Metadata::created

sync::atomic::Atomic{Usize,Isize,Bool,Ptr}::compare_exchange

sync::atomic::Atomic{Usize,Isize,Bool,Ptr}::compare_exchange_weak

collections::{btree,hash}_map::{Occupied,Vacant,}Entry::key

os::unix::net::{UnixStream, UnixListener, UnixDatagram, SocketAddr}

SocketAddr::is_unnamed

SocketAddr::as_pathname

UnixStream::connect

UnixStream::pair

UnixStream::try_clone

UnixStream::local_addr

UnixStream::peer_addr

UnixStream::set_read_timeout

UnixStream::set_write_timeout

UnixStream::read_timeout

UnixStream::write_timeout

UnixStream::set_nonblocking

UnixStream::take_error

UnixStream::shutdown

Read/Write/RawFd impls for UnixStream

UnixListener::bind

UnixListener::accept

UnixListener::try_clone

UnixListener::local_addr

UnixListener::set_nonblocking

UnixListener::take_error

UnixListener::incoming

RawFd impls for UnixListener

UnixDatagram::bind

UnixDatagram::unbound

UnixDatagram::pair

UnixDatagram::connect

UnixDatagram::try_clone

UnixDatagram::local_addr

UnixDatagram::peer_addr

UnixDatagram::recv_from

UnixDatagram::recv

UnixDatagram::send_to

UnixDatagram::send

UnixDatagram::set_read_timeout

UnixDatagram::set_write_timeout

UnixDatagram::read_timeout

UnixDatagram::write_timeout

UnixDatagram::set_nonblocking

UnixDatagram::take_error

UnixDatagram::shutdown

RawFd impls for UnixDatagram

{BTree,Hash}Map::values_mut

<[_]>::binary_search_by_key

The abs_sub method of floats is deprecated. The semantics of this minor method are subtle and probably not what most people want.

Add implementation of Ord for Cell and RefCell where T: Ord.

On Linux, if HashMaps can't be initialized with getrandom they will fall back to /dev/urandom temporarily to avoid blocking during early boot.

Implemented negation for wrapping numerals.

Implement Clone for binary_heap::IntoIter.

Implement Display and Hash for std::num::Wrapping.

Add Default implementation for &CStr, CString.

Implement From> and Into> for VecDeque.

Implement Default for UnsafeCell, fmt::Error, Condvar, Mutex, RwLock.

Cargo.toml supports the profile.*.panic option. This controls the runtime behavior of the panic! macro and can be either "unwind" (the default), or "abort". RFC 1513.

Don't throw away errors with -p arguments.

Report status to stderr instead of stdout.

Build scripts are passed a CARGO_MANIFEST_LINKS environment variable that corresponds to the links field of the manifest.

Ban keywords from crate names.

Canonicalize CARGO_HOME on Windows.

Retry network requests. By default they are retried twice, which can be customized with the net.retry value in .cargo/config.

Don't print extra error info for failing subcommands.

Add --force flag to cargo install.

Don't use flock on NFS mounts.

Prefer building cargo install artifacts in temporary directories. Makes it possible to install multiple crates in parallel.

Add cargo test --doc.

Add cargo --explain.

Don't print warnings when -q is passed.

Add cargo doc --lib and --bin.

Don't require build script output to be UTF-8.

Correctly attempt multiple git usernames.

rustc memory usage was reduced by refactoring the context used for type checking.

Speed up creation of HashMaps by caching the random keys used to initialize the hash state.

The find implementation for Chain iterators is 2x faster.

Trait selection optimizations speed up type checking by 15%.

Efficient trie lookup for boolean Unicode properties. 10x faster than the previous lookup tables.

Special case #[derive(Copy, Clone)] to avoid bloat.

Many incremental improvements to documentation and rustdoc.

rustdoc: List blanket trait impls.

rustdoc: Clean up ABI rendering.

Indexing with the wrong type produces a more informative error.

Improve diagnostics for constants being used in irrefutable patterns.

When many method candidates are in scope limit the suggestions to 10.

Remove confusing suggestion when calling a fn type.

Do not suggest changing &mut self to &mut mut self.

Update i686-linux-android features to match Android ABI.

Update aarch64-linux-android features to match Android ABI.

std no longer prints backtraces on platforms where the running module must be loaded with env::current_exe, which can't be relied on.

This release includes std binaries for the i586-unknown-linux-gnu, i686-unknown-linux-musl, and armv7-linux-androideabi targets. The i586 target is for old x86 hardware without SSE2, and the armv7 target is for Android running on modern ARM architectures.

The rust-gdb and rust-lldb scripts are distributed on all Unix platforms.

On Unix the runtime aborts by calling libc::abort instead of generating an illegal instruction.

Rust is now bootstrapped from the previous release of Rust, instead of a snapshot from an arbitrary commit.

AtomicBool is now bool-sized, not word-sized.

target_env for Linux ARM targets is just gnu, not gnueabihf, gnueabi, etc.

Consistently panic on overflow in Duration::new.

Change String::truncate to panic less.

Add :block to the follow set for :ty and :path. Affects how macros are parsed.

Fix macro hygiene bug.

Feature-gated attributes on macro-generated macro invocations are now rejected.

Suppress fallback and ambiguity errors during type inference. This caused some minor changes to type inference.

Support nested cfg_attr attributes

Allow statement-generating braced macro invocations at the end of blocks

Macros can be expanded inside of trait definitions

#[macro_use] works properly when it is itself expanded from a macro

BinaryHeap::append

BTreeMap::append

BTreeMap::split_off

BTreeSet::append

BTreeSet::split_off

f32::to_degrees (in libcore - previously stabilized in libstd)

f32::to_radians (in libcore - previously stabilized in libstd)

f64::to_degrees (in libcore - previously stabilized in libstd)

f64::to_radians (in libcore - previously stabilized in libstd)

Iterator::sum

Iterator::product

Cell::get_mut

RefCell::get_mut

The thread_local! macro supports multiple definitions in a single invocation, and can apply attributes

Cow implements Default

Wrapping implements binary, octal, lower-hex and upper-hex Display formatting

The range types implement Hash

lookup_host ignores unknown address types

assert_eq! accepts a custom error message, like assert! does

The main thread is now called "main" instead of "

Disallow specifying features of transitive deps

Add color support for Windows consoles

Fix harness = false on [lib] sections

Don't panic when links contains a '.'

Build scripts can emit warnings, and -vv prints warnings for all crates.

Ignore file locks on OS X NFS mounts

Don't warn about package.metadata keys. This provides room for expansion by arbitrary tools.

Add support for cdylib crate types

Prevent publishing crates when files are dirty

Don't fetch all crates on clean

Propagate --color option to rustc

Fix cargo doc --open on Windows

Improve autocompletion

Configure colors of stderr as well as stdout

Caching projections speeds up type check dramatically for some workloads

The default HashMap hasher is SipHash 1-3 instead of SipHash 2-4 This hasher is faster, but is believed to provide sufficient protection from collision attacks.

Comparison of Ipv4Addr is 10x faster

Fix empty implementation section on some module pages

Fix inlined renamed re-exports in import lists

Fix search result layout for enum variants and struct fields

Fix issues with source links to external crates

Fix redirect pages for renamed re-exports

rustc is better at finding the MSVC toolchain

When emitting debug info, rustc emits frame pointers for closures, shims and glue, as it does for all other functions

rust-lldb warns about unsupported versions of LLDB

Many more errors have been given error codes and extended explanations

API documentation continues to be improved, with many new examples

rustc no longer hangs when dependencies recursively re-export submodules

rustc requires LLVM 3.7+

The 'How Safe and Unsafe Interact' chapter of The Rustonomicon was rewritten

rustc support 16-bit pointer sizes. No targets use this yet, but it works toward AVR support.

consts and statics may not have unsized types

The new follow-set rules that place restrictions on macro_rules! in order to ensure syntax forward-compatibility have been enabled This was an amendment to RFC 550, and has been a warning since 1.10.

cfg attribute process has been refactored to fix various bugs. This causes breakage in some corner cases.

rustc translates code to LLVM IR via its own "middle" IR (MIR). This translation pass is far simpler than the previous AST->LLVM pass, and creates opportunities to perform new optimizations directly on the MIR. It was previously described on the Rust blog.

rustc presents a new, more readable error format, along with machine-readable JSON error output for use by IDEs. Most common editors supporting Rust have been updated to work with it. It was previously described on the Rust blog.

rustc translates code to LLVM IR via its own "middle" IR (MIR). This translation pass is far simpler than the previous AST->LLVM pass, and creates opportunities to perform new optimizations directly on the MIR. It was previously described on the Rust blog.

Print the Rust target name, not the LLVM target name, with --print target-list

The computation of TypeId is correct in some cases where it was previously producing inconsistent results

The mips-unknown-linux-gnu target uses hardware floating point by default

The rustc arguments, --print target-cpus, --print target-features, --print relocation-models, and --print code-models print the available options to the -C target-cpu, -C target-feature, -C relocation-model and -C code-model code generation arguments

rustc supports three new MUSL targets on ARM: arm-unknown-linux-musleabi, arm-unknown-linux-musleabihf, and armv7-unknown-linux-musleabihf. These targets produce statically-linked binaries. There are no binary release builds yet though.

rustc presents a new, more readable error format, along with machine-readable JSON error output for use by IDEs. Most common editors supporting Rust have been updated to work with it. It was previously described on the Rust blog.

In error descriptions, references are now described in plain English, instead of as "&-ptr"

In error type descriptions, unknown numeric types are named {integer} or {float} instead of _

rustc emits a clearer error when inner attributes follow a doc comment

macro_rules! invocations can be made within macro_rules! invocations

macro_rules! meta-variables are hygienic

macro_rules! tt matchers can be reparsed correctly, making them much more useful

macro_rules! stmt matchers correctly consume the entire contents when inside non-braces invocations

Semicolons are properly required as statement delimiters inside macro_rules! invocations

cfg_attr works on path attributes

Cell::as_ptr

RefCell::as_ptr

IpAddr::is_unspecified

IpAddr::is_loopback

IpAddr::is_multicast

Ipv4Addr::is_unspecified

Ipv6Addr::octets

LinkedList::contains

VecDeque::contains

ExitStatusExt::from_raw. Both on Unix and Windows.

Receiver::recv_timeout

RecvTimeoutError

BinaryHeap::peek_mut

PeekMut

iter::Product

iter::Sum

OccupiedEntry::remove_entry

VacantEntry::into_key

The format! macro and friends now allow a single argument to be formatted in multiple styles

The lifetime bounds on [T]::binary_search_by and [T]::binary_search_by_key have been adjusted to be more flexible

Option implements From for its contained type

Cell, RefCell and UnsafeCell implement From for their contained type

RwLock panics if the reader count overflows

vec_deque::Drain, hash_map::Drain and hash_set::Drain are covariant

vec::Drain and binary_heap::Drain are covariant

Cow<str> implements FromIterator for char, &str and String

Sockets on Linux are correctly closed in subprocesses via SOCK_CLOEXEC

hash_map::Entry, hash_map::VacantEntry and hash_map::OccupiedEntry implement Debug

btree_map::Entry, btree_map::VacantEntry and btree_map::OccupiedEntry implement Debug

String implements AddAssign

Variadic extern fn pointers implement the Clone, PartialEq, Eq, PartialOrd, Ord, Hash, fmt::Pointer, and fmt::Debug traits

FileType implements Debug

References to Mutex and RwLock are unwind-safe

mpsc::sync_channel Receivers return any available message before reporting a disconnect

Unicode definitions have been updated to 9.0

env iterators implement DoubleEndedIterator

Support local mirrors of registries

Add support for command aliases

Allow opt-level="s" / opt-level="z" in profile overrides

Make cargo doc --open --target work as expected

Speed up noop registry updates

Update OpenSSL

Fix --panic=abort with plugins

Always pass -C metadata to the compiler

Fix depending on git repos with workspaces

Add a --lib flag to cargo new

Add http.cainfo for custom certs

Indicate the compilation profile after compiling

Allow enabling features for dependencies with --features

Add --jobs flag to cargo package

Add --dry-run to cargo publish

Add support for RUSTDOCFLAGS

panic::catch_unwind is more optimized

panic::catch_unwind no longer accesses thread-local storage on entry

Test binaries now support a --test-threads argument to specify the number of threads used to run tests, and which acts the same as the RUST_TEST_THREADS environment variable

The test runner now emits a warning when tests run over 60 seconds

rustdoc: Fix methods in search results

rust-lldb warns about unsupported versions of LLDB

Rust releases now come with source packages that can be installed by rustup via rustup component add rust-src. The resulting source code can be used by tools and IDES, located in the sysroot under lib/rustlib/src.

The compiler can now be built against LLVM 3.9

Many minor improvements to the documentation.

The Rust exception handling "personality" routine is now written in Rust

When printing Windows OsStrs, unpaired surrogate codepoints are escaped with the lowercase format instead of the uppercase

When formatting strings, if "precision" is specified, the "fill", "align" and "width" specifiers are no longer ignored

The Debug impl for strings no longer escapes all non-ASCII characters

ICE: 'rustc' panicked at 'assertion failed: concrete_substs.is_normalized_for_trans()' #36381

Confusion with double negation and booleans

rustc 1.12.0 fails with SIGSEGV in release mode (syn crate 0.8.0)

Rustc 1.12.0 Windows build of ethcore crate fails with LLVM error

1.12.0: High memory usage when linking in release mode with debug info

Corrupted memory after updated to 1.12

"Let NullaryConstructor = something;" causes internal compiler error: "tried to overwrite interned AdtDef"

Fix ICE: inject bitcast if types mismatch for invokes/calls/stores

debuginfo: Handle spread_arg case in MIR-trans in a more stable way.

Stabilize the ? operator. ? is a simple way to propagate errors, like the try! macro, described in RFC 0243.

Stabilize macros in type position. Described in RFC 873.

Stabilize attributes on statements. Described in RFC 0016.

Fix #[derive] for empty tuple structs/variants

Fix lifetime rules for 'if' conditions

Avoid loading and parsing unconfigured non-inline modules

Add the -C link-arg argument

Remove the old AST-based backend from rustc_trans

Don't enable NEON by default on armv7 Linux

Fix debug line number info for macro expansions

Do not emit "class method" debuginfo for types that are not DICompositeType

Warn about multiple conflicting #[repr] hints

When sizing DST, don't double-count nested struct prefixes

Default RUST_MIN_STACK to 16MiB for now

Improve rlib metadata format. Reduces rlib size significantly.

Reject macros with empty repetitions to avoid infinite loop

Expand macros without recursing to avoid stack overflows

Replace macro backtraces with labeled local uses

Improve error message for misplaced doc comments

Buffer unix and lock windows to prevent message interleaving

Update lifetime errors to specifically note temporaries

Special case a few colors for Windows

Suggest use self when such an import resolves

Be more specific when type parameter shadows primitive type

Many minor improvements

Compute and cache HIR hashes at beginning

Don't hash types in loan paths

Cache projections in trans

Optimize the parser's last token handling

Only instantiate #[inline] functions in codegen units referencing them. This leads to big improvements in cases where crates export define many inline functions without using them directly.

Lazily allocate TypedArena's first chunk

Don't allocate during default HashSet creation

checked_abs

wrapping_abs

overflowing_abs

RefCell::try_borrow

RefCell::try_borrow_mut

Add assert_ne! and debug_assert_ne!

Make vec_deque::Drain, hash_map::Drain, and hash_set::Drain covariant

Implement AsRef<[T]> for std::slice::Iter

Implement Debug for std::vec::IntoIter

CString: avoid excessive growth just to 0-terminate

Implement CoerceUnsized for {Cell, RefCell, UnsafeCell}

Use arc4rand on FreeBSD

memrchr: Correct aligned offset computation

Improve Demangling of Rust Symbols

Use monotonic time in condition variables

Implement Debug for std::path::{Components,Iter}

Implement conversion traits for char

Fix illegal instruction caused by overflow in channel cloning

Zero first byte of CString on drop

Inherit overflow checks for sum and product

Add missing Eq implementations

Implement Debug for DirEntry

When getaddrinfo returns EAI_SYSTEM retrieve actual error from errno

SipHasher is deprecated. Use DefaultHasher.

Implement more traits for std::io::ErrorKind

Optimize BinaryHeap bounds checking

Work around pointer aliasing issue in Vec::extend_from_slice, extend_with_element

Fix overflow checking in unsigned pow()

This release includes security fixes to both curl and OpenSSL.

Fix transitive doctests when panic=abort

Add --all-features flag to cargo

Reject path-based dependencies in cargo package

Don't parse the home directory more than once

Don't try to generate Cargo.lock on empty workspaces

Update OpenSSL to 1.0.2j

Add license and license_file to cargo metadata output

Make crates-io registry URL optional in config; ignore all changes to source.crates-io

Don't download dependencies from other platforms

Build transitive dev-dependencies when needed

Add support for per-target rustflags in .cargo/config

Avoid updating registry when adding existing deps

Warn about path overrides that won't work

Use workspaces during cargo install

Leak mspdbsrv.exe processes on Windows

Add --message-format flag

Pass target environment for rustdoc

Use CommandExt::exec for cargo run on Unix

Update curl and curl-sys

Call rustdoc test with the correct cfg flags of a package

rustdoc: Add the --sysroot argument

rustdoc: Fix a couple of issues with the search results

rustdoc: remove the ! from macro URLs and titles

gdb: Fix pretty-printing special-cased Rust types

rustdoc: Filter more incorrect methods inherited through Deref

Remove unmaintained style guide

Add s390x support

Initial work at Haiku OS support

Add mips-uclibc targets

Crate-ify compiler-rt into compiler-builtins

Add rustc version info (git hash + date) to dist tarball

Many documentation improvements

SipHasher is deprecated. Use DefaultHasher.

Deny (by default) transmuting from fn item types to pointer-sized types. Continuing the long transition to zero-sized fn items, per RFC 401.

Fix #[derive] for empty tuple structs/variants. Part of RFC 1506.

Issue deprecation warnings for safe accesses to extern statics

Fix lifetime rules for 'if' conditions.

Inherit overflow checks for sum and product.

Forbid user-defined macros named "macro_rules".

.. matches multiple tuple fields in enum variants, structs and tuples. RFC 1492.

Safe fn items can be coerced to unsafe fn pointers

use * and use ::* both glob-import from the crate root

It's now possible to call a Vec<Box> without explicit dereferencing

Mark enums with non-zero discriminant as non-zero

Lower-case static mut names are linted like other statics and consts

Fix ICE on some macros in const integer positions (e.g. [u8; m!()])

Improve error message and snippet for "did you mean x"

Add a panic-strategy field to the target specification

Include LLVM version in --version --verbose

Improve macro expansion performance

Shrink Expr_::ExprInlineAsm

Replace all uses of SHA-256 with BLAKE2b

Reduce the number of bytes hashed by IchHasher

Avoid more allocations when compiling html5ever

Use SmallVector in CombineFields::instantiate

Avoid some allocations in the macro parser

Use a faster deflate setting

Add ArrayVec and AccumulateVec to reduce heap allocations during interning of slices

Optimize write_metadata

Don't process obligation forest cycles when stalled

Avoid many CrateConfig clones

Optimize Substs::super_fold_with

Optimize ObligationForest's NodeState handling

Speed up plug_leaks

println!(), with no arguments, prints newline. Previously, an empty string was required to achieve the same.

Wrapping impls standard binary and unary operators, as well as the Sum and Product iterators

Implement From> for String and From> for Vec

Improve fold performance for chain, cloned, map, and VecDeque iterators

Improve SipHasher performance on small values

Add Iterator trait TrustedLen to enable better FromIterator / Extend

Expand .zip() specialization to .map() and .cloned()

ReadDir implements Debug

Implement RefUnwindSafe for atomic types

Specialize Vec::extend to Vec::extend_from_slice

Avoid allocations in Decoder::read_str

io::Error implements From<io::ErrorKind>

Impl Debug for raw pointers to unsized data

Don't reuse HashMap random seeds

The internal memory layout of HashMap is more cache-friendly, for significant improvements in some operations

HashMap uses less memory on 32-bit architectures

Impl Add<{str, Cow<str>}> for Cow<str>

Expose rustc cfg values to build scripts

Allow cargo to work with read-only CARGO_HOME

Fix passing --features when testing multiple packages

Use a single profile set per workspace

Load replace sections from lock files

Ignore panic configuration for test/bench profiles

rustup is the recommended Rust installation method

This release includes host (rustc) builds for Linux on MIPS, PowerPC, and S390x. These are tier 2 platforms and may have major defects. Follow the instructions on the website to install, or add the targets to an existing installation with rustup target add. The new target triples are:

• mips-unknown-linux-gnu

• mipsel-unknown-linux-gnu

• mips64-unknown-linux-gnuabi64

• mips64el-unknown-linux-gnuabi64

• powerpc-unknown-linux-gnu

• powerpc64-unknown-linux-gnu

• powerpc64le-unknown-linux-gnu

• s390x-unknown-linux-gnu

This release includes target (std) builds for ARM Linux running MUSL libc. These are tier 2 platforms and may have major defects. Add the following triples to an existing rustup installation with rustup target add:

• arm-unknown-linux-musleabi

• arm-unknown-linux-musleabihf

• armv7-unknown-linux-musleabihf

This release includes experimental support for WebAssembly, via the wasm32-unknown-emscripten target. This target is known to have major defects. Please test, report, and fix.

rustup no longer installs documentation by default. Run rustup component add rust-docs to install.

Fix line stepping in debugger

Enable line number debuginfo in releases

Disable jemalloc on aarch64/powerpc/mips

Add support for Fuchsia OS

Detect local-rebuild by only MAJOR.MINOR version

A number of forward-compatibility lints used by the compiler to gradually introduce language changes have been converted to deny by default:

• "use of inaccessible extern crate erroneously allowed"

• "type parameter default erroneously allowed in invalid location"

• "detects super or self keywords at the beginning of global path"

• "two overlapping inherent impls define an item with the same name were erroneously allowed"

• "floating-point constants cannot be used in patterns"

• "constants of struct or enum type can only be used in a pattern if the struct or enum has #[derive(PartialEq, Eq)]"

• "lifetimes or labels named '_ were erroneously allowed"

Prohibit patterns in trait methods without bodies

The atomic Ordering enum may not be matched exhaustively

Future-proofing #[no_link] breaks some obscure cases

The $crate macro variable is accepted in fewer locations

Impls specifying extra region requirements beyond the trait they implement are rejected

Enums may not be unsized. Unsized enums are intended to work but never have. For now they are forbidden.

Enforce the shadowing restrictions from RFC 1560 for today's macros

Basic procedural macros allowing custom #[derive], aka "macros 1.1", are stable. This allows popular code-generating crates like Serde and Diesel to work ergonomically. RFC 1681.

Tuple structs may be empty. Unary and empty tuple structs may be instantiated with curly braces. Part of RFC 1506.

A number of minor changes to name resolution have been activated. They add up to more consistent semantics, allowing for future evolution of Rust macros. Specified in RFC 1560, see its section on "changes" for details of what is different. The breaking changes here have been transitioned through the legacy_imports lint since 1.14, with no known regressions.

In macro_rules, path fragments can now be parsed as type parameter bounds

?Sized can be used in where clauses

There is now a limit on the size of monomorphized types and it can be modified with the #![type_size_limit] crate attribute, similarly to the #![recursion_limit] attribute

On Windows, the compiler will apply dllimport attributes when linking to extern functions. Additional attributes and flags can control which library kind is linked and its name. RFC 1717.

Rust-ABI symbols are no longer exported from cdylibs

The --test flag works with procedural macro crates

Fix extern "aapcs" fn ABI

The -C no-stack-check flag is deprecated. It does nothing.

The format! expander recognizes incorrect printf and shell-style formatting directives and suggests the correct format.

Only report one error for all unused imports in an import list

Avoid unnecessary mk_ty calls in Ty::super_fold_with

Avoid more unnecessary mk_ty calls in Ty::super_fold_with

Don't clone in UnificationTable::probe

Remove scope_auxiliary to cut RSS by 10%

Use small vectors in type walker

Macro expansion performance was improved

Change HirVec<P> to HirVec in hir::Expr

Replace FNV with a faster hash function

std::iter::Iterator::min_by

std::iter::Iterator::max_by

std::os::*::fs::FileExt

std::sync::atomic::Atomic*::get_mut

std::sync::atomic::Atomic*::into_inner

std::vec::IntoIter::as_slice

std::vec::IntoIter::as_mut_slice

std::sync::mpsc::Receiver::try_iter

std::os::unix::process::CommandExt::before_exec

std::rc::Rc::strong_count

std::rc::Rc::weak_count

std::sync::Arc::strong_count

std::sync::Arc::weak_count

std::char::encode_utf8

std::char::encode_utf16

std::cell::Ref::clone

std::io::Take::into_inner

The standard sorting algorithm has been rewritten for dramatic performance improvements. It is a hybrid merge sort, drawing influences from Timsort. Previously it was a naive merge sort.

Iterator::nth no longer has a Sized bound

Extend<&T> is specialized for Vec where T: Copy to improve performance.

chars().count() is much faster and so are chars().last() and char_indices().last()

Fix ARM Objective-C ABI in std::env::args

Chinese characters display correctly in fmt::Debug

Derive Default for Duration

Support creation of anonymous pipes on WinXP/2k

mpsc::RecvTimeoutError implements Error

Don't pass overlapped handles to processes

In this release, Cargo build scripts no longer have access to the OUT_DIR environment variable at build time via env!("OUT_DIR"). They should instead check the variable at runtime with std::env. That the value was set at build time was a bug, and incorrect when cross-compiling. This change is known to cause breakage.

Add --all flag to cargo test

Compile statically against the MSVC CRT

Mix feature flags into fingerprint/metadata shorthash

Link OpenSSL statically on OSX

Apply new fingerprinting to build dir outputs

Test for bad path overrides with summaries

Require cargo install --vers to take a semver version

Fix retrying crate downloads for network errors

Implement string lookup for build.rustflags config key

Emit more info on --message-format=json

Assume build.rs in the same directory as Cargo.toml is a build script

Don't ignore errors in workspace manifest

Fix --message-format JSON when rustc emits non-JSON warnings

Test runners (binaries built with --test) now support a --list argument that lists the tests it contains

Test runners now support a --exact argument that makes the test filter match exactly, instead of matching only a substring of the test name

rustdoc supports a --playground-url flag

rustdoc provides more details about #[should_panic] errors

The Rust build system is now written in Rust. The Makefiles may continue to be used in this release by passing --disable-rustbuild to the configure script, but they will be deleted soon. Note that the new build system uses a different on-disk layout that will likely affect any scripts building Rust.

Rust supports i686-unknown-openbsd. Tier 3 support. No testing or releases.

Rust supports the MSP430. Tier 3 support. No testing or releases.

Rust supports the ARMv5TE architecture. Tier 3 support. No testing or releases.

A number of minor changes to name resolution have been activated. They add up to more consistent semantics, allowing for future evolution of Rust macros. Specified in RFC 1560, see its section on "changes" for details of what is different. The breaking changes here have been transitioned through the legacy_imports lint since 1.14, with no known regressions.

In this release, Cargo build scripts no longer have access to the OUT_DIR environment variable at build time via env!("OUT_DIR"). They should instead check the variable at runtime with std::env. That the value was set at build time was a bug, and incorrect when cross-compiling. This change is known to cause breakage.

Higher-ranked lifetimes are no longer allowed to appear only in associated types. The hr_lifetime_in_assoc_type lint has been a warning since 1.10 and is now an error by default. It will become a hard error in the near future.

The semantics relating modules to file system directories are changing in minor ways. This is captured in the new legacy_directory_ownership lint, which is a warning in this release, and will become a hard error in the future.

Rust-ABI symbols are no longer exported from cdylibs

Once Peekable peeks a None it will return that None without re-querying the underlying iterator

The compiler's dead_code lint now accounts for type aliases.

Uninhabitable enums (those without any variants) no longer permit wildcard match patterns

Clean up semantics of self in an import list

Self may appear in impl headers

Self may appear in struct expressions

rustc now supports --emit=metadata, which causes rustc to emit a .rmeta file containing only crate metadata. This can be used by tools like the Rust Language Service to perform metadata-only builds.

Levenshtein based typo suggestions now work in most places, while previously they worked only for fields and sometimes for local variables. Together with the overhaul of "no resolution"/"unexpected resolution" errors (#38154) they result in large and systematic improvement in resolution diagnostics.

Fix transmute:: where T requires a bigger alignment than U

rustc: use -Xlinker when specifying an rpath with ',' in it