| Age | Commit message (Collapse) | Author | Lines |
|
If there's no TLS key just yet, then there's nothing to unsafely borrow, so
continue returning None. This prevents causing the runtime to abort itself when
logging before the runtime is fully initialized.
Closes #9487
r? @brson
|
|
find src -name '*.rs' | xargs sed -i '' 's/~~~.*{\.rust}/```rust/g'
find src -name '*.rs' | xargs sed -i '' 's/ ~~~$/ ```/g'
find src -name '*.rs' | xargs sed -i '' 's/^~~~$/ ```/g'
|
|
If there's no TLS key just yet, then there's nothing to unsafely borrow, so
continue returning None. This prevents causing the runtime to abort itself when
logging before the runtime is fully initialized.
Closes #9487
|
|
This fixes private statics and functions from being usable cross-crates, along
with some bad privacy error messages. This is a reopening of #8365 with all the
privacy checks in privacy.rs instead of resolve.rs (where they should be
anyway).
These maps of exported items will hopefully get used for generating
documentation by rustdoc
Closes #8592
|
|
This is required by the check-fast target because each test is slurped up into a
submodule.
|
|
As documented in issue #7945, these literal identifiers are all accepted by rust
today, but they should probably be disallowed (especially `'''`). This changes
all escapable sequences to being *required* to be escaped.
Closes #7945
I wanted to write the tests with more exact spans, but I think #9308 will be fixing that?
|
|
As documented in issue #7945, these literal identifiers are all accepted by rust
today, but they should probably be disallowed (especially `'''`). This changes
all escapable sequences to being *required* to be escaped.
Closes #7945
|
|
Progress on #7981
This doesn't completely close the issue because `struct A;` is still allowed, and it's a much larger change to disallow that. I'm also not entirely sure that we want to disallow that. Regardless, punting that discussion to the issue instead.
|
|
Progress on #7981
|
|
This fixes private statics and functions from being usable cross-crates, along
with some bad privacy error messages. This is a reopening of #8365 with all the
privacy checks in privacy.rs instead of resolve.rs (where they should be
anyway).
These maps of exported items will hopefully get used for generating
documentation by rustdoc
Closes #8592
|
|
|
|
|
|
|
|
|
|
|
|
Get rid of the crate_map arg!
r? @brson
|
|
Also, documentation & general clean-up:
- remove `gen_char_from`: better served by `sample` or `choose`.
- `gen_bytes` generalised to `gen_vec`.
- `gen_int_range`/`gen_uint_range` merged into `gen_integer_range` and
made to be properly uniformly distributed. Fixes #8644.
Minor adjustments to other functions.
|
|
|
|
This was a dead end experiment, and not a sensible way of implementing
generic data parallelism. This also removes the `graph500-bfs.rs`
benchmark because it relies on `extra::par`.
Closes #5626
|
|
pnkfelix/rust/fsk-issue-4691-catch-bad-fsu-during-compute-moves, r=nikomatsakis
Resolves third bullet of #4691: if the functional-struct-update (FSU) expression `{ a: b, ..s }` causes `s` to move and `s` has a destructor, then the expression is illegal.
r? @nikomatsakis
|
|
Many people will be very confused that their debug! statements aren't working
when they first use rust only to learn that they should have been building with
`--cfg debug` the entire time. This inverts the meaning of the flag to instead
of enabling debug statements, now it disables debug statements.
This way the default behavior is a bit more reasonable, and requires less
end-user configuration. Furthermore, this turns on debug by default when
building the rustc compiler.
|
|
It is intended to optimize/beautify the code generated in a few trivial trait operations.
Let's take the following code as an example:
```
trait Stuff {
fn bar(&self);
}
fn callBar(s: &Stuff) {
s.bar();
}
struct Foo;
impl Stuff for Foo {
fn bar(&self) {
}
}
pub fn main() {
let o = Foo;
callBar(&o as &Stuff);
}
```
At present it is translated into something like:
```
define void @_ZN7callBar_UUID.0E({ i32, %tydesc*, i8*, i8*, i8 }*, { %tydesc*, i8* }*) #4 {
"function top level":
%__trait_callee = alloca { %tydesc*, i8* }
%__auto_borrow_obj = alloca { %tydesc*, i8* }
%2 = getelementptr inbounds { %tydesc*, i8* }* %1, i32 0, i32 0
%3 = load %tydesc** %2
%4 = getelementptr inbounds { %tydesc*, i8* }* %__auto_borrow_obj, i32 0, i32 0
store %tydesc* %3, %tydesc** %4
%5 = getelementptr inbounds { %tydesc*, i8* }* %1, i32 0, i32 1
%6 = load i8** %5
%7 = getelementptr inbounds { %tydesc*, i8* }* %__auto_borrow_obj, i32 0, i32 1
store i8* %6, i8** %7
%8 = bitcast { %tydesc*, i8* }* %__auto_borrow_obj to i8*
%9 = bitcast { %tydesc*, i8* }* %__trait_callee to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* %9, i8* %8, i32 8, i32 4, i1 false)
%10 = getelementptr inbounds { %tydesc*, i8* }* %__trait_callee, i32 0, i32 1
%11 = load i8** %10
%12 = bitcast i8* %11 to { i32, %tydesc*, i8*, i8*, i8 }*
%13 = getelementptr inbounds { %tydesc*, i8* }* %__trait_callee, i32 0, i32 0
%14 = bitcast %tydesc** %13 to [1 x i8*]**
%15 = load [1 x i8*]** %14
%16 = getelementptr inbounds [1 x i8*]* %15, i32 0, i32 1
%17 = load i8** %16
%18 = bitcast i8* %17 to void ({ i32, %tydesc*, i8*, i8*, i8 }*)*
call void %18({ i32, %tydesc*, i8*, i8*, i8 }* %12)
ret void
}
...
define void @_ZN4main_UUID.0E({ i32, %tydesc*, i8*, i8*, i8 }*) #4 {
"function top level":
%o = alloca %struct.Foo
%1 = alloca { %tydesc*, i8* }
%__auto_borrow_obj = alloca { %tydesc*, i8* }
%2 = getelementptr inbounds { %tydesc*, i8* }* %1, i32 0, i32 1
%3 = bitcast i8** %2 to %struct.Foo**
store %struct.Foo* %o, %struct.Foo** %3
%4 = getelementptr inbounds { %tydesc*, i8* }* %1, i32 0, i32 0
%5 = bitcast %tydesc** %4 to { %tydesc*, void ({ i32, %tydesc*, i8*, i8*, i8 }*)* }**
store { %tydesc*, void ({ i32, %tydesc*, i8*, i8*, i8 }*)* }* @vtable1081, { %tydesc*, void ({ i32, %tydesc*, i8*, i8*, i8 }*)* }** %5
%6 = getelementptr inbounds { %tydesc*, i8* }* %1, i32 0, i32 0
%7 = load %tydesc** %6
%8 = getelementptr inbounds { %tydesc*, i8* }* %__auto_borrow_obj, i32 0, i32 0
store %tydesc* %7, %tydesc** %8
%9 = getelementptr inbounds { %tydesc*, i8* }* %1, i32 0, i32 1
%10 = load i8** %9
%11 = getelementptr inbounds { %tydesc*, i8* }* %__auto_borrow_obj, i32 0, i32 1
store i8* %10, i8** %11
call void @_ZN7callBar_UUID.0E({ i32, %tydesc*, i8*, i8*, i8 }* undef, { %tydesc*, i8* }* %__auto_borrow_obj)
ret void
}
```
If you apply my patch, it would become way shorter and cleaner:
```
define void @_ZN7callBar_UUID.0E({ i32, %tydesc*, i8*, i8*, i8 }*, { %tydesc*, i8* }*) #4 {
"function top level":
%2 = getelementptr inbounds { %tydesc*, i8* }* %1, i32 0, i32 1
%3 = load i8** %2
%4 = bitcast i8* %3 to { i32, %tydesc*, i8*, i8*, i8 }*
%5 = getelementptr inbounds { %tydesc*, i8* }* %1, i32 0, i32 0
%6 = bitcast %tydesc** %5 to [1 x i8*]**
%7 = load [1 x i8*]** %6
%8 = getelementptr inbounds [1 x i8*]* %7, i32 0, i32 1
%9 = load i8** %8
%10 = bitcast i8* %9 to void ({ i32, %tydesc*, i8*, i8*, i8 }*)*
call void %10({ i32, %tydesc*, i8*, i8*, i8 }* %4)
ret void
}
...
define void @_ZN4main_UUID.0E({ i32, %tydesc*, i8*, i8*, i8 }*) #4 {
"function top level":
%o = alloca %struct.Foo
%1 = alloca { %tydesc*, i8* }
%2 = getelementptr inbounds { %tydesc*, i8* }* %1, i32 0, i32 1
%3 = bitcast i8** %2 to %struct.Foo**
store %struct.Foo* %o, %struct.Foo** %3
%4 = getelementptr inbounds { %tydesc*, i8* }* %1, i32 0, i32 0
%5 = bitcast %tydesc** %4 to { %tydesc*, void ({ i32, %tydesc*, i8*, i8*, i8 }*)* }**
store { %tydesc*, void ({ i32, %tydesc*, i8*, i8*, i8 }*)* }* @vtable1081, { %tydesc*, void ({ i32, %tydesc*, i8*, i8*, i8 }*)* }** %5
call void @_ZN7callBar_UUID.0E({ i32, %tydesc*, i8*, i8*, i8 }* undef, { %tydesc*, i8* }* %1)
ret void
}
```
Although this change doesn't increase the compilation speed much (I mentioned only about 1-2% boost on "rustc -O -Z time-passes syntax.rs"), but I still think it's a good thing to do as it greatly simplifies/clarifies LL generated in some cases which would definitely help in the future code generation investigations.
I don't provide any new test cases in this patch as it is merely an optimization.
Sorry guys, I somehow messed my previous PR and I don't see any better way to fix as to recreate it here.
|
|
This is for consistency in naming conventions.
- ``std::num::Float::NaN()`` is changed to ``nan()``;
- ``std::num::Float.is_NaN()`` is changed to ``is_nan()``; and
- ``std::num::strconv::NumStrConv::NaN()`` is changed to ``nan()``.
Fixes #9319.
|
|
chris-morgan/rust/unreachable-macro-part-two-of-two-containing-the-destruction-of-the-unreachable-function, r=alexcrichton
This is the second of two parts of #8991, now possible as a new snapshot
has been made. (The first part implemented the unreachable!() macro; it
was #8992, 6b7b8f2682.)
``std::util::unreachable()`` is removed summarily; any code which used
it should now use the ``unreachable!()`` macro.
Closes #9312.
Closes #8991.
|
|
Previously, the lexer calling `rdr.fatal(...)` would report the span of
the last complete token, instead of a span within the erroneous token
(besides one span fixed in 1ac90bb).
This branch adds wrappers around `rdr.fatal(...)` that sets the span
explicilty, so that all fatal errors in `libsyntax/parse/lexer.rs` now
report the offending code more precisely. A number of tests try to
verify that, though the `compile-fail` testing setup can only check that
the spans are on the right lines, and the "unterminated string/block
comment" errors can't have the line marked at all, so that's incomplete.
This closes #9149.
Also, the lexer errors now report the offending code in the error message,
not just via the span, just like other errors do.
|
|
The `Drop` implementation was used to prevent `Future` from being implicitly copyable. Since `~fn`s are no longer copyable, this is no longer needed. I added a cfail test to make sure that this is actually the case.
I method-ized all of the `Future` creation methods and added a new one, `spawn_with`, which is similar to `task::spawn_with`.
I also got rid of some unused imports in tests.
|
|
|
|
|
|
|
|
|
|
|
|
Also add a test to help prevent this from getting out of sync again.
|
|
|
|
It was only there to prevent Future from being copyable, but it's
noncopyable anyways since it contains a ~fn.
|
|
Previously, the lexer calling `rdr.fatal(...)` would report the span of
the last complete token, instead of a span within the erroneous token
(besides one span fixed in 1ac90bb).
This commit adds a wrapper around `rdr.fatal(...)` that sets the span
explicilty, so that all fatal errors in `libsyntax/parse/lexer.rs` now
report the offending code more precisely. A number of tests try to
verify that, though the `compile-fail` testing setup can only check that
the spans are on the right lines, and the "unterminated string/block
comment" errors can't have the line marked at all, so that's incomplete.
Closes #9149.
|
|
This is more consistent with other parts of the language and it also makes it
easier to use in situations where format string is massive.
|
|
This is for consistency in naming conventions.
- ``std::num::Float::NaN()`` is changed to ``nan()``;
- ``std::num::Float.is_NaN()`` is changed to ``is_nan()``; and
- ``std::num::strconv::NumStrConv::NaN()`` is changed to ``nan()``.
Fixes #9319.
|
|
|
|
Some minor api and doc adjustments
|
|
This is my first contribution, so please point out anything that I may have missed.
I consulted IRC and settled on `match () { ... }` for most of the replacements.
|
|
This is the second of two parts of #8991, now possible as a new snapshot
has been made. (The first part implemented the unreachable!() macro; it
was #8992, 6b7b8f2682.)
``std::util::unreachable()`` is removed summarily; any code which used
it should now use the ``unreachable!()`` macro.
Closes #9312.
Closes #8991.
|
|
|
|
This is more consistent with other parts of the language and it also makes it
easier to use in situations where format string is massive.
|
|
Also add a test to help prevent this from getting out of sync again.
|
|
|
|
Since 3b6314c the pretty printer seems to only print trait bounds for `ast::ty_path(...)`s that have a generics arguments list. That seems wrong, so let's always print them.
Closes #9253, un-xfails test for #7673.
|
|
Fix Rust build on mingw v4.0
See #9246 for details.
|
|
This commit adds support for `\0` escapes in character and string literals.
Since `\0` is equivalent to `\x00`, this is a direct translation to the latter
escape sequence. Future builds will be able to compile using `\0` directly.
Also updated the grammar specification and added a test for NUL characters.
|
|
Since 3b6314c3 the pretty printer seems to only print trait bounds for
`ast::ty_path(...)`s that have a generics arguments list. That seems
wrong, so let's always print them.
Closes #9253, un-xfails test for #7673.
|
|
If a static is flagged as address_insignificant, then for LLVM to actually
perform the relevant optimization it must have an internal linkage type. What
this means, though, is that the static will not be available to other crates.
Hence, if you have a generic function with an inner static, it will fail to link
when built as a library because other crates will attempt to use the inner
static externally.
This gets around the issue by inlining the static into the metadata. The same
relevant optimization is then applied separately in the external crate. What
this ends up meaning is that all statics tagged with #[address_insignificant]
will appear at most once per crate (by value), but they could appear in multiple
crates.
This should be the last blocker for using format! ...
|