https://github.com/rust-lang/rust http://git.dreamy.place/mirrors/rust/atom?h=1.10.0 2016-03-20T17:04:55+00:00 2016-03-20T17:04:55+00:00 Sean McArthur sean.monstar@gmail.com 2016-03-05T02:49:43+00:00 urn:sha1:e0945937c4d6786af0b03a11c8cec2c34cde7662 2015-10-07T22:02:45+00:00 Michael Pankov work@michaelpankov.com 2015-10-07T22:01:02+00:00 urn:sha1:17033a62b420fcf353150998bbdb62629efdf956 Rest is blocked by https://github.com/nrc/rustfmt/issues/413 2015-06-17T16:06:59+00:00 Alex Crichton alex@alexcrichton.com 2015-06-09T18:18:03+00:00 urn:sha1:c14d86fd3ff3ba2d01a6e859290b30e74081313b This commit shards the broad `core` feature of the libcore library into finer grained features. This split groups together similar APIs and enables tracking each API separately, giving a better sense of where each feature is within the stabilization process. A few minor APIs were deprecated along the way: * Iterator::reverse_in_place * marker::NoCopy 2015-04-29T00:23:45+00:00 Tamir Duberstein tamird@gmail.com 2015-04-27T21:10:49+00:00 urn:sha1:69abc12b0044d641e714bdd73a299cfa4136b7b8 2015-04-13T05:01:55+00:00 Ryan Prichard ryan.prichard@gmail.com 2015-04-01T20:36:53+00:00 urn:sha1:9cdc9e9c614089c294cb19837919fdc0653c2b14 Arguments, Formatters, and the various format traits remain stable. The format_args! macro uses #[allow_internal_unstable] to allow it access to the unstable things in core::fmt. Destabilized things include a "v1" in their name: * core::fmt::rt * core::fmt::rt::v1 (the module and all contents) * core::fmt::ArgumentV1 * core::fmt::ArgumentV1::new * core::fmt::ArgumentV1::from_usize * core::fmt::Arguments::new_v1 * core::fmt::Arguments::new_v1_formatted The unstable message was copied from that of std::io::_print. 2015-04-01T15:23:45+00:00 Niko Matsakis niko@alum.mit.edu 2015-03-30T13:40:52+00:00 urn:sha1:c35c46821a69af14e6b38e0238f70e22433a3e8e 2015-02-27T00:48:49+00:00 Flavio Percoco flaper87@gmail.com 2015-02-25T12:48:53+00:00 urn:sha1:9d0d72345df8e9b2b27899f70f0d7b7222524948 2015-02-23T03:07:38+00:00 Nick Cameron ncameron@mozilla.com 2015-02-23T03:07:38+00:00 urn:sha1:67b03fbc3d44c88df160ba4ba6922b01f4c7675e 2015-02-02T18:38:32+00:00 Jorge Aparicio japaricious@gmail.com 2015-01-31T14:16:56+00:00 urn:sha1:134cf707dfb8f37d735d20ff261366b7c2d916a6 2015-01-30T17:21:56+00:00 Alex Crichton alex@alexcrichton.com 2015-01-13T23:42:53+00:00 urn:sha1:62273575139a80c2b208a3a27e0c2392b1425be6 This commit performs a final stabilization pass over the std::fmt module, marking all necessary APIs as stable. One of the more interesting aspects of this module is that it exposes a good deal of its runtime representation to the outside world in order for `format_args!` to be able to construct the format strings. Instead of hacking the compiler to assume that these items are stable, this commit instead lays out a story for the stabilization and evolution of these APIs. There are three primary details used by the `format_args!` macro: 1. `Arguments` - an opaque package of a "compiled format string". This structure is passed around and the `write` function is the source of truth for transforming a compiled format string into a string at runtime. This must be able to be constructed in stable code. 2. `Argument` - an opaque structure representing an argument to a format string. This is *almost* a trait object as it's just a pointer/function pair, but due to the function originating from one of many traits, it's not actually a trait object. Like `Arguments`, this must be constructed from stable code. 3. `fmt::rt` - this module contains the runtime type definitions primarily for the `rt::Argument` structure. Whenever an argument is formatted with nonstandard flags, a corresponding `rt::Argument` is generated describing how the argument is being formatted. This can be used to construct an `Arguments`. The primary interface to `std::fmt` is the `Arguments` structure, and as such this type name is stabilize as-is today. It is expected for libraries to pass around an `Arguments` structure to represent a pending formatted computation. The remaining portions are largely "cruft" which would rather not be stabilized, but due to the stability checks they must be. As a result, almost all pieces have been renamed to represent that they are "version 1" of the formatting representation. The theory is that at a later date if we change the representation of these types we can add new definitions called "version 2" and corresponding constructors for `Arguments`. One of the other remaining large questions about the fmt module were how the pending I/O reform would affect the signatures of methods in the module. Due to [RFC 526][rfc], however, the writers of fmt are now incompatible with the writers of io, so this question has largely been solved. As a result the interfaces are largely stabilized as-is today. [rfc]: https://github.com/rust-lang/rfcs/blob/master/text/0526-fmt-text-writer.md Specifically, the following changes were made: * The contents of `fmt::rt` were all moved under `fmt::rt::v1` * `fmt::rt` is stable * `fmt::rt::v1` is stable * `Error` is stable * `Writer` is stable * `Writer::write_str` is stable * `Writer::write_fmt` is stable * `Formatter` is stable * `Argument` has been renamed to `ArgumentV1` and is stable * `ArgumentV1::new` is stable * `ArgumentV1::from_uint` is stable * `Arguments::new_v1` is stable (renamed from `new`) * `Arguments::new_v1_formatted` is stable (renamed from `with_placeholders`) * All formatting traits are now stable, as well as the `fmt` method. * `fmt::write` is stable * `fmt::format` is stable * `Formatter::pad_integral` is stable * `Formatter::pad` is stable * `Formatter::write_str` is stable * `Formatter::write_fmt` is stable * Some assorted top level items which were only used by `format_args!` were removed in favor of static functions on `ArgumentV1` as well. * The formatting-flag-accessing methods remain unstable Within the contents of the `fmt::rt::v1` module, the following actions were taken: * Reexports of all enum variants were removed * All prefixes on enum variants were removed * A few miscellaneous enum variants were renamed * Otherwise all structs, fields, and variants were marked stable. In addition to these actions in the `std::fmt` module, many implementations of `Show` and `String` were stabilized as well. In some other modules: * `ToString` is now stable * `ToString::to_string` is now stable * `Vec` no longer implements `fmt::Writer` (this has moved to `String`) This is a breaking change due to all of the changes to the `fmt::rt` module, but this likely will not have much impact on existing programs. Closes #20661 [breaking-change]