Skip to content

Commit 897847e

Browse files
dreiddreid
committed
---
yaml --- r: 217085 b: refs/heads/stable c: f539c41 h: refs/heads/master i: 217083: 0a7665d v: v3
1 parent e4ed87d commit 897847e

File tree

71 files changed

+205
-263
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

71 files changed

+205
-263
lines changed

‎[refs]

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -29,5 +29,5 @@ refs/heads/tmp: 378a370ff2057afeb1eae86eb6e78c476866a4a6
2929
refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
3030
refs/tags/homu-tmp: a5286998df566e736b32f6795bfc3803bdaf453d
3131
refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
32-
refs/heads/stable: 0cbef048173f8b1bc6be1bd9ea64a9f07e737bd4
32+
refs/heads/stable: f539c416a0ef87c645de26b67e01a047afcb0b2a
3333
refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375

‎branches/stable/src/doc/reference.md

Lines changed: 1 addition & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -3529,9 +3529,7 @@ The actual implementation for each vtable entry can vary on an object-by-object
35293529
basis.
35303530

35313531
Note that for a trait object to be instantiated, the trait must be
3532-
_object-safe_. Object safety rules are defined in [RFC 255].
3533-
3534-
[RFC 255]: https://github.com/rust-lang/rfcs/blob/master/text/0255-object-safety.md
3532+
_object-safe_. Object safety rules are defined in [RFC 255][rfc255].
35353533

35363534
Given a pointer-typed expression `E` of type `&T` or `Box<T>`, where `T`
35373535
implements trait `R`, casting `E` to the corresponding pointer type `&R` or

‎branches/stable/src/doc/trpl/iterators.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -42,7 +42,7 @@ loop is just a handy way to write this `loop`/`match`/`break` construct.
4242
`for` loops aren't the only thing that uses iterators, however. Writing your
4343
own iterator involves implementing the `Iterator` trait. While doing that is
4444
outside of the scope of this guide, Rust provides a number of useful iterators
45-
to accomplish various threads. Before we talk about those, we should talk about a
45+
to accomplish various tasks. Before we talk about those, we should talk about a
4646
Rust anti-pattern. And that's using ranges like this.
4747

4848
Yes, we just talked about how ranges are cool. But ranges are also very

‎branches/stable/src/doc/trpl/the-stack-and-the-heap.md

Lines changed: 23 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -80,15 +80,15 @@ This memory is kind of like a giant array: addresses start at zero and go
8080
up to the final number. So here’s a diagram of our first stack frame:
8181

8282
| Address | Name | Value |
83-
|---------|------|-------|
83+
+---------+------+-------+
8484
| 0 | x | 42 |
8585

8686
We’ve got `x` located at address `0`, with the value `42`.
8787

8888
When `foo()` is called, a new stack frame is allocated:
8989

9090
| Address | Name | Value |
91-
|---------|------|-------|
91+
+---------+------+-------+
9292
| 2 | z | 100 |
9393
| 1 | y | 5 |
9494
| 0 | x | 42 |
@@ -107,7 +107,7 @@ value being stored.
107107
After `foo()` is over, its frame is deallocated:
108108

109109
| Address | Name | Value |
110-
|---------|------|-------|
110+
+---------+------+-------+
111111
| 0 | x | 42 |
112112

113113
And then, after `main()`, even this last value goes away. Easy!
@@ -142,13 +142,13 @@ fn main() {
142142
Okay, first, we call `main()`:
143143

144144
| Address | Name | Value |
145-
|---------|------|-------|
145+
+---------+------+-------+
146146
| 0 | x | 42 |
147147

148148
Next up, `main()` calls `foo()`:
149149

150150
| Address | Name | Value |
151-
|---------|------|-------|
151+
+---------+------+-------+
152152
| 3 | c | 1 |
153153
| 2 | b | 100 |
154154
| 1 | a | 5 |
@@ -157,7 +157,7 @@ Next up, `main()` calls `foo()`:
157157
And then `foo()` calls `bar()`:
158158

159159
| Address | Name | Value |
160-
|---------|------|-------|
160+
+---------+------+-------+
161161
| 4 | i | 6 |
162162
| 3 | c | 1 |
163163
| 2 | b | 100 |
@@ -170,7 +170,7 @@ After `bar()` is over, its frame is deallocated, leaving just `foo()` and
170170
`main()`:
171171

172172
| Address | Name | Value |
173-
|---------|------|-------|
173+
+---------+------+-------+
174174
| 3 | c | 1 |
175175
| 2 | b | 100 |
176176
| 1 | a | 5 |
@@ -179,7 +179,7 @@ After `bar()` is over, its frame is deallocated, leaving just `foo()` and
179179
And then `foo()` ends, leaving just `main()`
180180

181181
| Address | Name | Value |
182-
|---------|------|-------|
182+
+---------+------+-------+
183183
| 0 | x | 42 |
184184

185185
And then we’re done. Getting the hang of it? It’s like piling up dishes: you
@@ -206,7 +206,7 @@ fn main() {
206206
Here’s what happens in memory when `main()` is called:
207207

208208
| Address | Name | Value |
209-
|---------|------|--------|
209+
+---------+------+--------+
210210
| 1 | y | 42 |
211211
| 0 | x | ?????? |
212212

@@ -218,7 +218,7 @@ it allocates some memory for the heap, and puts `5` there. The memory now looks
218218
like this:
219219

220220
| Address | Name | Value |
221-
|-----------------|------|----------------|
221+
+-----------------+------+----------------+
222222
| 2<sup>30</sup> | | 5 |
223223
| ... | ... | ... |
224224
| 1 | y | 42 |
@@ -243,7 +243,7 @@ layout of a program which has been running for a while now:
243243

244244

245245
| Address | Name | Value |
246-
|----------------------|------|----------------------|
246+
+----------------------+------+----------------------+
247247
| 2<sup>30</sup> | | 5 |
248248
| (2<sup>30</sup>) - 1 | | |
249249
| (2<sup>30</sup>) - 2 | | |
@@ -272,7 +272,7 @@ when it was created. Great! So when `x` goes away, it first frees the memory
272272
allocated on the heap:
273273

274274
| Address | Name | Value |
275-
|---------|------|--------|
275+
+---------+------+--------+
276276
| 1 | y | 42 |
277277
| 0 | x | ?????? |
278278

@@ -305,7 +305,7 @@ fn main() {
305305
When we enter `main()`, memory looks like this:
306306

307307
| Address | Name | Value |
308-
|---------|------|-------|
308+
+---------+------+-------+
309309
| 1 | y | 0 |
310310
| 0 | x | 5 |
311311

@@ -315,7 +315,7 @@ memory location that `x` lives at, which in this case is `0`.
315315
What about when we call `foo()`, passing `y` as an argument?
316316

317317
| Address | Name | Value |
318-
|---------|------|-------|
318+
+---------+------+-------+
319319
| 3 | z | 42 |
320320
| 2 | i | 0 |
321321
| 1 | y | 0 |
@@ -367,7 +367,7 @@ fn main() {
367367
First, we call `main()`:
368368

369369
| Address | Name | Value |
370-
|-----------------|------|----------------|
370+
+-----------------+------+----------------+
371371
| 2<sup>30</sup> | | 20 |
372372
| ... | ... | ... |
373373
| 2 | j | 0 |
@@ -380,7 +380,7 @@ value pointing there.
380380
Next, at the end of `main()`, `foo()` gets called:
381381

382382
| Address | Name | Value |
383-
|-----------------|------|----------------|
383+
+-----------------+------+----------------+
384384
| 2<sup>30</sup> | | 20 |
385385
| ... | ... | ... |
386386
| 5 | z | 4 |
@@ -397,7 +397,7 @@ since `j` points at `h`.
397397
Next, `foo()` calls `baz()`, passing `z`:
398398

399399
| Address | Name | Value |
400-
|-----------------|------|----------------|
400+
+-----------------+------+----------------+
401401
| 2<sup>30</sup> | | 20 |
402402
| ... | ... | ... |
403403
| 7 | g | 100 |
@@ -413,7 +413,7 @@ We’ve allocated memory for `f` and `g`. `baz()` is very short, so when it’s
413413
over, we get rid of its stack frame:
414414

415415
| Address | Name | Value |
416-
|-----------------|------|----------------|
416+
+-----------------+------+----------------+
417417
| 2<sup>30</sup> | | 20 |
418418
| ... | ... | ... |
419419
| 5 | z | 4 |
@@ -426,7 +426,7 @@ over, we get rid of its stack frame:
426426
Next, `foo()` calls `bar()` with `x` and `z`:
427427

428428
| Address | Name | Value |
429-
|----------------------|------|----------------------|
429+
+----------------------+------+----------------------+
430430
| 2<sup>30</sup> | | 20 |
431431
| (2<sup>30</sup>) - 1 | | 5 |
432432
| ... | ... | ... |
@@ -449,7 +449,7 @@ case, we set up the variables as usual.
449449
At the end of `bar()`, it calls `baz()`:
450450

451451
| Address | Name | Value |
452-
|----------------------|------|----------------------|
452+
+----------------------+------+----------------------+
453453
| 2<sup>30</sup> | | 20 |
454454
| (2<sup>30</sup>) - 1 | | 5 |
455455
| ... | ... | ... |
@@ -473,7 +473,7 @@ far.
473473
After `baz()` is over, we get rid of `f` and `g`:
474474

475475
| Address | Name | Value |
476-
|----------------------|------|----------------------|
476+
+----------------------+------+----------------------+
477477
| 2<sup>30</sup> | | 20 |
478478
| (2<sup>30</sup>) - 1 | | 5 |
479479
| ... | ... | ... |
@@ -493,7 +493,7 @@ Next, we return from `bar()`. `d` in this case is a `Box<T>`, so it also frees
493493
what it points to: (2<sup>30</sup>) - 1.
494494

495495
| Address | Name | Value |
496-
|-----------------|------|----------------|
496+
+-----------------+------+----------------+
497497
| 2<sup>30</sup> | | 20 |
498498
| ... | ... | ... |
499499
| 5 | z | 4 |
@@ -506,7 +506,7 @@ what it points to: (2<sup>30</sup>) - 1.
506506
And after that, `foo()` returns:
507507

508508
| Address | Name | Value |
509-
|-----------------|------|----------------|
509+
+-----------------+------+----------------+
510510
| 2<sup>30</sup> | | 20 |
511511
| ... | ... | ... |
512512
| 2 | j | 0 |

‎branches/stable/src/librustc_back/archive.rs

Lines changed: 0 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -306,21 +306,6 @@ impl<'a> ArchiveBuilder<'a> {
306306
if filename.contains(".SYMDEF") { continue }
307307
if skip(filename) { continue }
308308

309-
// Archives on unix systems typically do not have slashes in
310-
// filenames as the `ar` utility generally only uses the last
311-
// component of a path for the filename list in the archive. On
312-
// Windows, however, archives assembled with `lib.exe` will preserve
313-
// the full path to the file that was placed in the archive,
314-
// including path separators.
315-
//
316-
// The code below is munging paths so it'll go wrong pretty quickly
317-
// if there's some unexpected slashes in the filename, so here we
318-
// just chop off everything but the filename component. Note that
319-
// this can cause duplicate filenames, but that's also handled below
320-
// as well.
321-
let filename = Path::new(filename).file_name().unwrap()
322-
.to_str().unwrap();
323-
324309
// An archive can contain files of the same name multiple times, so
325310
// we need to be sure to not have them overwrite one another when we
326311
// extract them. Consequently we need to find a truly unique file

‎branches/stable/src/librustc_resolve/lib.rs

Lines changed: 2 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -2528,18 +2528,15 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
25282528
// If anything ends up here entirely resolved,
25292529
// it's an error. If anything ends up here
25302530
// partially resolved, that's OK, because it may
2531-
// be a `T::CONST` that typeck will resolve.
2531+
// be a `T::CONST` that typeck will resolve to
2532+
// an inherent impl.
25322533
if path_res.depth == 0 {
25332534
self.resolve_error(
25342535
path.span,
25352536
&format!("`{}` is not an enum variant, struct or const",
25362537
token::get_ident(
25372538
path.segments.last().unwrap().identifier)));
25382539
} else {
2539-
let const_name = path.segments.last().unwrap()
2540-
.identifier.name;
2541-
let traits = self.get_traits_containing_item(const_name);
2542-
self.trait_map.insert(pattern.id, traits);
25432540
self.record_def(pattern.id, path_res);
25442541
}
25452542
}

0 commit comments

Comments
 (0)