Skip to content

Commit 9d6520f

Browse files
borsbors
authored
Auto merge of #35769 - eddyb:rollup, r=eddyb
Rollup of 12 pull requests - Successful merges: #35346, #35734, #35739, #35740, #35742, #35744, #35749, #35750, #35751, #35756, #35766, #35768 - Failed merges:
2 parents 169b612 + d69cd72 commit 9d6520f

Some content is hidden

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

45 files changed

+691
-79
lines changed

‎README.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,7 @@ Read ["Installing Rust"] from [The Book].
1919
* `g++` 4.7 or later or `clang++` 3.x
2020
* `python` 2.7 (but not 3.x)
2121
* GNU `make` 3.81 or later
22-
* `cmake` 2.8.8 or later
22+
* `cmake` 3.4.3 or later
2323
* `curl`
2424
* `git`
2525

‎mk/cfg/mips-unknown-linux-uclibc.mk

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1 @@
1+
# rustbuild-only target

‎mk/cfg/mipsel-unknown-linux-uclibc.mk

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1 @@
1+
# rustbuild-only target

‎src/bootstrap/mk/Makefile.in

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -22,6 +22,10 @@ BOOTSTRAP := $(CFG_PYTHON) $(CFG_SRC_DIR)src/bootstrap/bootstrap.py $(BOOTSTRAP_
2222
all:
2323
$(Q)$(BOOTSTRAP)
2424

25+
# Don’t use $(Q) here, always show how to invoke the bootstrap script directly
26+
help:
27+
$(BOOTSTRAP) --help
28+
2529
clean:
2630
$(Q)$(BOOTSTRAP) --clean
2731

‎src/librustc/hir/map/mod.rs

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -569,6 +569,13 @@ impl<'ast> Map<'ast> {
569569
}
570570
}
571571

572+
pub fn expect_impl_item(&self, id: NodeId) -> &'ast ImplItem {
573+
match self.find(id) {
574+
Some(NodeImplItem(item)) => item,
575+
_ => bug!("expected impl item, found {}", self.node_to_string(id))
576+
}
577+
}
578+
572579
pub fn expect_trait_item(&self, id: NodeId) -> &'ast TraitItem {
573580
match self.find(id) {
574581
Some(NodeTraitItem(item)) => item,

‎src/librustc/infer/error_reporting.rs

Lines changed: 5 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -523,6 +523,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
523523
pub fn note_type_err(&self,
524524
diag: &mut DiagnosticBuilder<'tcx>,
525525
origin: TypeOrigin,
526+
secondary_span: Option<(Span, String)>,
526527
values: Option<ValuePairs<'tcx>>,
527528
terr: &TypeError<'tcx>)
528529
{
@@ -553,6 +554,9 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
553554
}
554555

555556
diag.span_label(span, &terr);
557+
if let Some((sp, msg)) = secondary_span {
558+
diag.span_label(sp, &msg);
559+
}
556560

557561
self.note_error_origin(diag, &origin);
558562
self.check_and_note_conflicting_crates(diag, terr, span);
@@ -569,7 +573,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
569573
self.tcx.sess, trace.origin.span(), E0308,
570574
"{}", trace.origin.as_failure_str()
571575
);
572-
self.note_type_err(&mut diag, trace.origin, Some(trace.values), terr);
576+
self.note_type_err(&mut diag, trace.origin, None, Some(trace.values), terr);
573577
diag
574578
}
575579

‎src/librustc/traits/error_reporting.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -161,7 +161,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
161161
self.tcx.sess, origin.span(), E0271,
162162
"type mismatch resolving `{}`", predicate
163163
);
164-
self.note_type_err(&mut diag, origin, values, err);
164+
self.note_type_err(&mut diag, origin, None, values, err);
165165
self.note_obligation_cause(&mut diag, obligation);
166166
diag.emit();
167167
});

‎src/librustc_back/target/mips_unknown_linux_uclibc.rs

Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
2+
// file at the top-level directory of this distribution and at
3+
// http://rust-lang.org/COPYRIGHT.
4+
//
5+
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6+
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7+
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8+
// option. This file may not be copied, modified, or distributed
9+
// except according to those terms.
10+
11+
use target::{Target, TargetOptions, TargetResult};
12+
13+
pub fn target() -> TargetResult {
14+
Ok(Target {
15+
llvm_target: "mips-unknown-linux-uclibc".to_string(),
16+
target_endian: "big".to_string(),
17+
target_pointer_width: "32".to_string(),
18+
data_layout: "E-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64".to_string(),
19+
arch: "mips".to_string(),
20+
target_os: "linux".to_string(),
21+
target_env: "uclibc".to_string(),
22+
target_vendor: "unknown".to_string(),
23+
options: TargetOptions {
24+
cpu: "mips32r2".to_string(),
25+
features: "+mips32r2,+soft-float".to_string(),
26+
max_atomic_width: 32,
27+
..super::linux_base::opts()
28+
},
29+
})
30+
}

‎src/librustc_back/target/mipsel_unknown_linux_uclibc.rs

Lines changed: 31 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,31 @@
1+
// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
2+
// file at the top-level directory of this distribution and at
3+
// http://rust-lang.org/COPYRIGHT.
4+
//
5+
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6+
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7+
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8+
// option. This file may not be copied, modified, or distributed
9+
// except according to those terms.
10+
11+
use target::{Target, TargetOptions, TargetResult};
12+
13+
pub fn target() -> TargetResult {
14+
Ok(Target {
15+
llvm_target: "mipsel-unknown-linux-uclibc".to_string(),
16+
target_endian: "little".to_string(),
17+
target_pointer_width: "32".to_string(),
18+
data_layout: "e-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64".to_string(),
19+
arch: "mips".to_string(),
20+
target_os: "linux".to_string(),
21+
target_env: "uclibc".to_string(),
22+
target_vendor: "unknown".to_string(),
23+
24+
options: TargetOptions {
25+
cpu: "mips32".to_string(),
26+
features: "+mips32,+soft-float".to_string(),
27+
max_atomic_width: 32,
28+
..super::linux_base::opts()
29+
},
30+
})
31+
}

‎src/librustc_back/target/mod.rs

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -143,6 +143,8 @@ supported_targets! {
143143
("i686-unknown-linux-musl", i686_unknown_linux_musl),
144144
("mips-unknown-linux-musl", mips_unknown_linux_musl),
145145
("mipsel-unknown-linux-musl", mipsel_unknown_linux_musl),
146+
("mips-unknown-linux-uclibc", mips_unknown_linux_uclibc),
147+
("mipsel-unknown-linux-uclibc", mipsel_unknown_linux_uclibc),
146148

147149
("i686-linux-android", i686_linux_android),
148150
("arm-linux-androideabi", arm_linux_androideabi),

‎src/librustc_const_eval/check_match.rs

Lines changed: 5 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1121,10 +1121,11 @@ fn check_legality_of_move_bindings(cx: &MatchCheckCtxt,
11211121
.span_label(p.span, &format!("moves value into pattern guard"))
11221122
.emit();
11231123
} else if by_ref_span.is_some() {
1124-
let mut err = struct_span_err!(cx.tcx.sess, p.span, E0009,
1125-
"cannot bind by-move and by-ref in the same pattern");
1126-
span_note!(&mut err, by_ref_span.unwrap(), "by-ref binding occurs here");
1127-
err.emit();
1124+
struct_span_err!(cx.tcx.sess, p.span, E0009,
1125+
"cannot bind by-move and by-ref in the same pattern")
1126+
.span_label(p.span, &format!("by-move pattern here"))
1127+
.span_label(by_ref_span.unwrap(), &format!("both by-ref and by-move used"))
1128+
.emit();
11281129
}
11291130
};
11301131

‎src/librustc_mir/build/scope.rs

Lines changed: 59 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -198,8 +198,11 @@ impl<'tcx> Scope<'tcx> {
198198
///
199199
/// Should always be run for all inner scopes when a drop is pushed into some scope enclosing a
200200
/// larger extent of code.
201-
fn invalidate_cache(&mut self) {
202-
self.cached_exits = FnvHashMap();
201+
///
202+
/// `unwind` controls whether caches for the unwind branch are also invalidated.
203+
fn invalidate_cache(&mut self, unwind: bool) {
204+
self.cached_exits.clear();
205+
if !unwind { return; }
203206
for dropdata in &mut self.drops {
204207
if let DropKind::Value { ref mut cached_block } = dropdata.kind {
205208
*cached_block = None;
@@ -455,25 +458,65 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
455458
};
456459

457460
for scope in self.scopes.iter_mut().rev() {
458-
if scope.extent == extent {
461+
let this_scope = scope.extent == extent;
462+
// When building drops, we try to cache chains of drops in such a way so these drops
463+
// could be reused by the drops which would branch into the cached (already built)
464+
// blocks. This, however, means that whenever we add a drop into a scope which already
465+
// had some blocks built (and thus, cached) for it, we must invalidate all caches which
466+
// might branch into the scope which had a drop just added to it. This is necessary,
467+
// because otherwise some other code might use the cache to branch into already built
468+
// chain of drops, essentially ignoring the newly added drop.
469+
//
470+
// For example consider there’s two scopes with a drop in each. These are built and
471+
// thus the caches are filled:
472+
//
473+
// +--------------------------------------------------------+
474+
// | +---------------------------------+ |
475+
// | | +--------+ +-------------+ | +---------------+ |
476+
// | | | return | <-+ | drop(outer) | <-+ | drop(middle) | |
477+
// | | +--------+ +-------------+ | +---------------+ |
478+
// | +------------|outer_scope cache|--+ |
479+
// +------------------------------|middle_scope cache|------+
480+
//
481+
// Now, a new, inner-most scope is added along with a new drop into both inner-most and
482+
// outer-most scopes:
483+
//
484+
// +------------------------------------------------------------+
485+
// | +----------------------------------+ |
486+
// | | +--------+ +-------------+ | +---------------+ | +-------------+
487+
// | | | return | <+ | drop(new) | <-+ | drop(middle) | <--+| drop(inner) |
488+
// | | +--------+ | | drop(outer) | | +---------------+ | +-------------+
489+
// | | +-+ +-------------+ | |
490+
// | +---|invalid outer_scope cache|----+ |
491+
// +----=----------------|invalid middle_scope cache|-----------+
492+
//
493+
// If, when adding `drop(new)` we do not invalidate the cached blocks for both
494+
// outer_scope and middle_scope, then, when building drops for the inner (right-most)
495+
// scope, the old, cached blocks, without `drop(new)` will get used, producing the
496+
// wrong results.
497+
//
498+
// The cache and its invalidation for unwind branch is somewhat special. The cache is
499+
// per-drop, rather than per scope, which has a several different implications. Adding
500+
// a new drop into a scope will not invalidate cached blocks of the prior drops in the
501+
// scope. That is true, because none of the already existing drops will have an edge
502+
// into a block with the newly added drop.
503+
//
504+
// Note that this code iterates scopes from the inner-most to the outer-most,
505+
// invalidating caches of each scope visited. This way bare minimum of the
506+
// caches gets invalidated. i.e. if a new drop is added into the middle scope, the
507+
// cache of outer scpoe stays intact.
508+
let invalidate_unwind = needs_drop && !this_scope;
509+
scope.invalidate_cache(invalidate_unwind);
510+
if this_scope {
459511
if let DropKind::Value { .. } = drop_kind {
460512
scope.needs_cleanup = true;
461513
}
462-
463-
// No need to invalidate any caches here. The just-scheduled drop will branch into
464-
// the drop that comes before it in the vector.
465514
scope.drops.push(DropData {
466515
span: span,
467516
location: lvalue.clone(),
468517
kind: drop_kind
469518
});
470519
return;
471-
} else {
472-
// We must invalidate all the cached_blocks leading up to the scope we’re
473-
// looking for, because all of the blocks in the chain will become incorrect.
474-
if let DropKind::Value { .. } = drop_kind {
475-
scope.invalidate_cache()
476-
}
477520
}
478521
}
479522
span_bug!(span, "extent {:?} not in scope to drop {:?}", extent, lvalue);
@@ -490,11 +533,12 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
490533
value: &Lvalue<'tcx>,
491534
item_ty: Ty<'tcx>) {
492535
for scope in self.scopes.iter_mut().rev() {
536+
// See the comment in schedule_drop above. The primary difference is that we invalidate
537+
// the unwind blocks unconditionally. That’s because the box free may be considered
538+
// outer-most cleanup within the scope.
539+
scope.invalidate_cache(true);
493540
if scope.extent == extent {
494541
assert!(scope.free.is_none(), "scope already has a scheduled free!");
495-
// We also must invalidate the caches in the scope for which the free is scheduled
496-
// because the drops must branch into the free we schedule here.
497-
scope.invalidate_cache();
498542
scope.needs_cleanup = true;
499543
scope.free = Some(FreeData {
500544
span: span,
@@ -503,11 +547,6 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
503547
cached_block: None
504548
});
505549
return;
506-
} else {
507-
// We must invalidate all the cached_blocks leading up to the scope we’re looking
508-
// for, because otherwise some/most of the blocks in the chain will become
509-
// incorrect.
510-
scope.invalidate_cache();
511550
}
512551
}
513552
span_bug!(span, "extent {:?} not in scope to free {:?}", extent, value);

‎src/librustc_resolve/diagnostics.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -891,7 +891,7 @@ A `struct` variant name was used like a function name.
891891
Erroneous code example:
892892
893893
```compile_fail,E0423
894-
struct Foo { a: bool};
894+
struct Foo { a: bool };
895895
896896
let f = Foo();
897897
// error: `Foo` is a struct variant name, but this expression uses

‎src/librustc_resolve/lib.rs

Lines changed: 26 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -102,7 +102,7 @@ enum ResolutionError<'a> {
102102
/// error E0402: cannot use an outer type parameter in this context
103103
OuterTypeParameterContext,
104104
/// error E0403: the name is already used for a type parameter in this type parameter list
105-
NameAlreadyUsedInTypeParameterList(Name),
105+
NameAlreadyUsedInTypeParameterList(Name, &'a Span),
106106
/// error E0404: is not a trait
107107
IsNotATrait(&'a str),
108108
/// error E0405: use of undeclared trait name
@@ -209,13 +209,17 @@ fn resolve_struct_error<'b, 'a: 'b, 'c>(resolver: &'b Resolver<'a>,
209209
E0402,
210210
"cannot use an outer type parameter in this context")
211211
}
212-
ResolutionError::NameAlreadyUsedInTypeParameterList(name) => {
213-
struct_span_err!(resolver.session,
214-
span,
215-
E0403,
216-
"the name `{}` is already used for a type parameter in this type \
217-
parameter list",
218-
name)
212+
ResolutionError::NameAlreadyUsedInTypeParameterList(name, first_use_span) => {
213+
let mut err = struct_span_err!(resolver.session,
214+
span,
215+
E0403,
216+
"the name `{}` is already used for a type parameter \
217+
in this type parameter list",
218+
name);
219+
err.span_label(span, &format!("already used"));
220+
err.span_label(first_use_span.clone(), &format!("first use of `{}`", name));
221+
err
222+
219223
}
220224
ResolutionError::IsNotATrait(name) => {
221225
let mut err = struct_span_err!(resolver.session,
@@ -237,12 +241,14 @@ fn resolve_struct_error<'b, 'a: 'b, 'c>(resolver: &'b Resolver<'a>,
237241
err
238242
}
239243
ResolutionError::MethodNotMemberOfTrait(method, trait_) => {
240-
struct_span_err!(resolver.session,
241-
span,
242-
E0407,
243-
"method `{}` is not a member of trait `{}`",
244-
method,
245-
trait_)
244+
let mut err = struct_span_err!(resolver.session,
245+
span,
246+
E0407,
247+
"method `{}` is not a member of trait `{}`",
248+
method,
249+
trait_);
250+
err.span_label(span, &format!("not a member of `{}`", trait_));
251+
err
246252
}
247253
ResolutionError::TypeNotMemberOfTrait(type_, trait_) => {
248254
struct_span_err!(resolver.session,
@@ -1726,17 +1732,19 @@ impl<'a> Resolver<'a> {
17261732
match type_parameters {
17271733
HasTypeParameters(generics, rib_kind) => {
17281734
let mut function_type_rib = Rib::new(rib_kind);
1729-
let mut seen_bindings = HashSet::new();
1735+
let mut seen_bindings = HashMap::new();
17301736
for type_parameter in &generics.ty_params {
17311737
let name = type_parameter.ident.name;
17321738
debug!("with_type_parameter_rib: {}", type_parameter.id);
17331739

1734-
if seen_bindings.contains(&name) {
1740+
if seen_bindings.contains_key(&name) {
1741+
let span = seen_bindings.get(&name).unwrap();
17351742
resolve_error(self,
17361743
type_parameter.span,
1737-
ResolutionError::NameAlreadyUsedInTypeParameterList(name));
1744+
ResolutionError::NameAlreadyUsedInTypeParameterList(name,
1745+
span));
17381746
}
1739-
seen_bindings.insert(name);
1747+
seen_bindings.entry(name).or_insert(type_parameter.span);
17401748

17411749
// plain insert (no renaming)
17421750
let def_id = self.definitions.local_def_id(type_parameter.id);

0 commit comments

Comments
 (0)