- 17 5月, 2014 17 次提交
-
-
由 Alex Crichton 提交于
This is an implementation of RFC 16. A module can now only be loaded if the module declaring `mod name;` "owns" the current directory. A module is considered as owning its directory if it meets one of the following criteria: * It is the top-level crate file * It is a `mod.rs` file * It was loaded via `#[path]` * It was loaded via `include!` * The module was declared via an inline `mod foo { ... }` statement For example, this directory structure is now invalid // lib.rs mod foo; // foo.rs mod bar; // bar.rs; fn bar() {} With this change `foo.rs` must be renamed to `foo/mod.rs`, and `bar.rs` must be renamed to `foo/bar.rs`. This makes it clear that `bar` is a submodule of `foo`, and can only be accessed through `foo`. RFC: 0016-module-file-system-hierarchy Closes #14180 [breaking-change]
-
由 bors 提交于
Adds docs where previously there were no docs. Also adds windows support to libterm.
-
由 Corey Richardson 提交于
-
由 Corey Richardson 提交于
-
由 Corey Richardson 提交于
-
由 Corey Richardson 提交于
-
由 Corey Richardson 提交于
-
由 Corey Richardson 提交于
-
由 Corey Richardson 提交于
-
由 Corey Richardson 提交于
-
由 Corey Richardson 提交于
-
由 Corey Richardson 提交于
-
由 Corey Richardson 提交于
-
由 Corey Richardson 提交于
Closes #2807
-
由 Corey Richardson 提交于
-
由 Corey Richardson 提交于
-
由 Corey Richardson 提交于
-
- 16 5月, 2014 23 次提交
-
-
由 bors 提交于
By default, jemalloc is building itself with -g3 if the local compiler supports it. It looks like this is generating a good deal of debug info that windows isn't optimizing out (on the order of 18MB). Windows gcc/ld is also not optimizing this data away, causing hello world to be 18MB in size. There's no current real need for debugging jemalloc to a great extent, so this commit manually passes -g1 to override -g3 which jemalloc is using. This is confirmed to drop the size of executables on windows back to a more reasonable size (2.0MB, as they were before). Closes #14144
-
由 bors 提交于
-
由 bors 提交于
This was a more difficult change than I thought it would be, and it is unfortunately a breaking change rather than a drop-in replacement. Most of the rationale can be found in the third commit. cc #13851
-
由 Alex Crichton 提交于
-
由 Alex Crichton 提交于
-
由 Alex Crichton 提交于
In an attempt to phase out the std::num::strconv module's string formatting functionality, this commit reimplements some provided methods for formatting integers on top of format!() instead of the custom (and slower) implementation inside of num::strconv. Primarily, this deprecates int_to_str_bytes_common
-
由 Alex Crichton 提交于
This is a migration of the std::{f32, f64}::to_str* functionality to the core library. This removes the growable `Vec` used in favor of a large stack buffer. The maximum base 10 exponent for f64 is 308, so a stack buffer of 512 bytes should be sufficient to store all floats.
-
由 Alex Crichton 提交于
1. Wherever the `buf` field of a `Formatter` was used, the `Formatter` is used instead. 2. The usage of `write_fmt` is minimized as much as possible, the `write!` macro is preferred wherever possible. 3. Usage of `fmt::write` is minimized, favoring the `write!` macro instead.
-
由 Alex Crichton 提交于
These are reimplemented using the new `core::fmt` module.
-
由 Alex Crichton 提交于
Currently, the format_args!() macro takes as its first argument an expression which is the callee of an ExprCall. This means that if format_args!() is used with calling a method a closure must be used. Consider this code, however: format_args!(|args| { foo.writer.write_fmt(args) }, "{}", foo.field) The closure borrows the entire `foo` structure, disallowing the later borrow of `foo.field`. To preserve the semantics of the `write!` macro, it is also impossible to borrow specifically the `writer` field of the `foo` structure because it must be borrowed mutably, but the `foo` structure is not guaranteed to be mutable itself. This new macro is invoked like: format_args_method!(foo.writer, write_fmt, "{}", foo.field) This macro will generate an ExprMethodCall which allows the borrow checker to understand that `writer` and `field` should be borrowed separately. This macro is not strictly necessary, with DST or possibly UFCS other workarounds could be used. For now, though, it looks like this is required to implement the `write!` macro.
-
由 Alex Crichton 提交于
This new method, write_fmt(), is the one way to write a formatted list of arguments into a Writer stream. This has a special adaptor to preserve errors which occur on the writer. All macros will be updated to use this method explicitly.
-
由 Alex Crichton 提交于
These were temporarily moved to explicit implementations, but now that fmt is in core it's possible to derive again.
-
由 Alex Crichton 提交于
This is used quite extensively by core::fmt
-
由 Alex Crichton 提交于
With std::fmt having migrated, the failure macro can be expressed in its full glory.
-
由 Alex Crichton 提交于
Now that std::fmt is in libcore, it's possible to implement this as an inherit method rather than through extension traits. This commit also tweaks the failure interface of libcore to libstd to what it should be, one method taking &fmt::Arguments
-
由 Alex Crichton 提交于
This commit moves all possible functionality from the standard library's string formatting utilities into the core library. This is a breaking change, due to a few tweaks in the semantics of formatting: 1. In order to break the dependency on the std::io module, a new trait, FormatWriter was introduced in core::fmt. This is the trait which is used (instead of Writer) to format data into a stream. 2. The new FormatWriter trait has one method, write(), which takes some bytes and can return an error, but the error contains very little information. The intent for this trait is for an adaptor writer to be used around the standard library's Writer trait. 3. The fmt::write{,ln,_unsafe} methods no longer take &mut io::Writer, but rather &mut FormatWriter. Since this trait is less common, all functions were removed except fmt::write, and it is not intended to be invoked directly. The main API-breaking change here is that the fmt::Formatter structure will no longer expose its `buf` field. All previous code writing directly to `f.buf` using writer methods or the `write!` macro will now instead use `f` directly. The Formatter object itself implements the `Writer` trait itself for convenience, although it does not implement the `FormatWriter` trait. The fallout of these changes will be in the following commits. [breaking-change]
-
由 Alex Crichton 提交于
The Float trait in libstd is quite a large trait which has dependencies on cmath (libm) and such, which libcore cannot satisfy. It also has many functions that libcore can implement, however, as LLVM has intrinsics or they're just bit twiddling. This commit moves what it can of the Float trait from the standard library into libcore to allow floats to be usable in the core library. The remaining functions are now resident in a FloatMath trait in the standard library (in the prelude now). Previous code which was generic over just the Float trait may now need to be generic over the FloatMath trait. [breaking-change]
-
由 Alex Crichton 提交于
-
由 bors 提交于
Change `str::from_utf8_owned()` and `StrBuf::from_utf8()` to return `Result`. This allows the vector to be recovered when it contains invalid UTF-8.
-
由 Kevin Butler 提交于
-
由 bors 提交于
This used to be called `mangle` and was removed when the Robin Hood hash map came along, but it is a useful thing to have in certain situations (I just hit it with my Teepee header representation), so I want it back. The method is renamed to `find_with_or_insert_with`, also with the parameters swapped to make sense—find and then insert, not insert and then find. /cc @cgaebel
-
由 Chris Morgan 提交于
-
由 bors 提交于
Let's try this again!
-