Auto merge of #57019 - QuietMisdreavus:semi-revert-doctest-parsing, r=GuillaumeGomez
[beta] rustdoc: semi-revert libsyntax doctest parsing if a macro is wrapping main
Fixes https://github.com/rust-lang/rust/issues/56898
This is a patch to doctest parsing on beta (that i plan to "forward-port" to master) that reverts to the old text-based `fn main` scan if it found a macro invocation in the doctest but did not find a main function. This should solve situations like `allocator_api` which wrap their main functions in a macro invocation, but doesn't solve something like the initial version of `quicli` which used a macro to *generate* the main function. (Properly doing the latter involves running macro expansion before checking, which is a bit too involved for a beta fix.)
diff --git a/src/librustc/traits/auto_trait.rs b/src/librustc/traits/auto_trait.rs
index c3cca14..c590b34 100644
--- a/src/librustc/traits/auto_trait.rs
+++ b/src/librustc/traits/auto_trait.rs
@@ -334,7 +334,12 @@
continue;
}
- let result = select.select(&Obligation::new(dummy_cause.clone(), new_env, pred));
+ // Call infcx.resolve_type_vars_if_possible to see if we can
+ // get rid of any inference variables.
+ let obligation = infcx.resolve_type_vars_if_possible(
+ &Obligation::new(dummy_cause.clone(), new_env, pred)
+ );
+ let result = select.select(&obligation);
match &result {
&Ok(Some(ref vtable)) => {
@@ -369,7 +374,7 @@
}
&Ok(None) => {}
&Err(SelectionError::Unimplemented) => {
- if self.is_of_param(pred.skip_binder().trait_ref.substs) {
+ if self.is_param_no_infer(pred.skip_binder().trait_ref.substs) {
already_visited.remove(&pred);
self.add_user_pred(
&mut user_computed_preds,
@@ -631,18 +636,28 @@
finished_map
}
- pub fn is_of_param(&self, substs: &Substs<'_>) -> bool {
- if substs.is_noop() {
- return false;
- }
+ fn is_param_no_infer(&self, substs: &Substs<'_>) -> bool {
+ return self.is_of_param(substs.type_at(0)) &&
+ !substs.types().any(|t| t.has_infer_types());
+ }
- return match substs.type_at(0).sty {
+ pub fn is_of_param(&self, ty: Ty<'_>) -> bool {
+ return match ty.sty {
ty::Param(_) => true,
- ty::Projection(p) => self.is_of_param(p.substs),
+ ty::Projection(p) => self.is_of_param(p.self_ty()),
_ => false,
};
}
+ fn is_self_referential_projection(&self, p: ty::PolyProjectionPredicate<'_>) -> bool {
+ match p.ty().skip_binder().sty {
+ ty::Projection(proj) if proj == p.skip_binder().projection_ty => {
+ true
+ },
+ _ => false
+ }
+ }
+
pub fn evaluate_nested_obligations<
'b,
'c,
@@ -661,28 +676,77 @@
) -> bool {
let dummy_cause = ObligationCause::misc(DUMMY_SP, ast::DUMMY_NODE_ID);
- for (obligation, predicate) in nested
- .filter(|o| o.recursion_depth == 1)
+ for (obligation, mut predicate) in nested
.map(|o| (o.clone(), o.predicate.clone()))
{
let is_new_pred =
fresh_preds.insert(self.clean_pred(select.infcx(), predicate.clone()));
+ // Resolve any inference variables that we can, to help selection succeed
+ predicate = select.infcx().resolve_type_vars_if_possible(&predicate);
+
+ // We only add a predicate as a user-displayable bound if
+ // it involves a generic parameter, and doesn't contain
+ // any inference variables.
+ //
+ // Displaying a bound involving a concrete type (instead of a generic
+ // parameter) would be pointless, since it's always true
+ // (e.g. u8: Copy)
+ // Displaying an inference variable is impossible, since they're
+ // an internal compiler detail without a defined visual representation
+ //
+ // We check this by calling is_of_param on the relevant types
+ // from the various possible predicates
match &predicate {
&ty::Predicate::Trait(ref p) => {
- let substs = &p.skip_binder().trait_ref.substs;
+ if self.is_param_no_infer(p.skip_binder().trait_ref.substs)
+ && !only_projections
+ && is_new_pred {
- if self.is_of_param(substs) && !only_projections && is_new_pred {
self.add_user_pred(computed_preds, predicate);
}
predicates.push_back(p.clone());
}
&ty::Predicate::Projection(p) => {
- // If the projection isn't all type vars, then
- // we don't want to add it as a bound
- if self.is_of_param(p.skip_binder().projection_ty.substs) && is_new_pred {
- self.add_user_pred(computed_preds, predicate);
- } else {
+ debug!("evaluate_nested_obligations: examining projection predicate {:?}",
+ predicate);
+
+ // As described above, we only want to display
+ // bounds which include a generic parameter but don't include
+ // an inference variable.
+ // Additionally, we check if we've seen this predicate before,
+ // to avoid rendering duplicate bounds to the user.
+ if self.is_param_no_infer(p.skip_binder().projection_ty.substs)
+ && !p.ty().skip_binder().is_ty_infer()
+ && is_new_pred {
+ debug!("evaluate_nested_obligations: adding projection predicate\
+ to computed_preds: {:?}", predicate);
+
+ // Under unusual circumstances, we can end up with a self-refeential
+ // projection predicate. For example:
+ // <T as MyType>::Value == <T as MyType>::Value
+ // Not only is displaying this to the user pointless,
+ // having it in the ParamEnv will cause an issue if we try to call
+ // poly_project_and_unify_type on the predicate, since this kind of
+ // predicate will normally never end up in a ParamEnv.
+ //
+ // For these reasons, we ignore these weird predicates,
+ // ensuring that we're able to properly synthesize an auto trait impl
+ if self.is_self_referential_projection(p) {
+ debug!("evaluate_nested_obligations: encountered a projection
+ predicate equating a type with itself! Skipping");
+
+ } else {
+ self.add_user_pred(computed_preds, predicate);
+ }
+ }
+
+ // We can only call poly_project_and_unify_type when our predicate's
+ // Ty contains an inference variable - otherwise, there won't be anything to
+ // unify
+ if p.ty().skip_binder().has_infer_types() {
+ debug!("Projecting and unifying projection predicate {:?}",
+ predicate);
match poly_project_and_unify_type(select, &obligation.with(p.clone())) {
Err(e) => {
debug!(
diff --git a/src/librustc/traits/object_safety.rs b/src/librustc/traits/object_safety.rs
index 2909daf..a9afe75 100644
--- a/src/librustc/traits/object_safety.rs
+++ b/src/librustc/traits/object_safety.rs
@@ -190,7 +190,26 @@
// In the case of a trait predicate, we can skip the "self" type.
data.skip_binder().input_types().skip(1).any(|t| t.has_self_ty())
}
- ty::Predicate::Projection(..) |
+ ty::Predicate::Projection(ref data) => {
+ // And similarly for projections. This should be redundant with
+ // the previous check because any projection should have a
+ // matching `Trait` predicate with the same inputs, but we do
+ // the check to be safe.
+ //
+ // Note that we *do* allow projection *outputs* to contain
+ // `self` (i.e., `trait Foo: Bar<Output=Self::Result> { type Result; }`),
+ // we just require the user to specify *both* outputs
+ // in the object type (i.e., `dyn Foo<Output=(), Result=()>`).
+ //
+ // This is ALT2 in issue #56288, see that for discussion of the
+ // possible alternatives.
+ data.skip_binder()
+ .projection_ty
+ .trait_ref(self)
+ .input_types()
+ .skip(1)
+ .any(|t| t.has_self_ty())
+ }
ty::Predicate::WellFormed(..) |
ty::Predicate::ObjectSafe(..) |
ty::Predicate::TypeOutlives(..) |
diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs
index 4633ab1..3adb7f1 100644
--- a/src/librustc/ty/mod.rs
+++ b/src/librustc/ty/mod.rs
@@ -1754,17 +1754,19 @@
pub struct AdtFlags: u32 {
const NO_ADT_FLAGS = 0;
const IS_ENUM = 1 << 0;
- const IS_PHANTOM_DATA = 1 << 1;
- const IS_FUNDAMENTAL = 1 << 2;
- const IS_UNION = 1 << 3;
- const IS_BOX = 1 << 4;
+ const IS_UNION = 1 << 1;
+ const IS_STRUCT = 1 << 2;
+ const HAS_CTOR = 1 << 3;
+ const IS_PHANTOM_DATA = 1 << 4;
+ const IS_FUNDAMENTAL = 1 << 5;
+ const IS_BOX = 1 << 6;
/// Indicates whether the type is an `Arc`.
- const IS_ARC = 1 << 5;
+ const IS_ARC = 1 << 7;
/// Indicates whether the type is an `Rc`.
- const IS_RC = 1 << 6;
+ const IS_RC = 1 << 8;
/// Indicates whether the variant list of this ADT is `#[non_exhaustive]`.
/// (i.e., this flag is never set unless this ADT is an enum).
- const IS_VARIANT_LIST_NON_EXHAUSTIVE = 1 << 7;
+ const IS_VARIANT_LIST_NON_EXHAUSTIVE = 1 << 9;
}
}
@@ -2079,31 +2081,43 @@
repr: ReprOptions) -> Self {
debug!("AdtDef::new({:?}, {:?}, {:?}, {:?})", did, kind, variants, repr);
let mut flags = AdtFlags::NO_ADT_FLAGS;
- let attrs = tcx.get_attrs(did);
- if attr::contains_name(&attrs, "fundamental") {
- flags = flags | AdtFlags::IS_FUNDAMENTAL;
- }
- if Some(did) == tcx.lang_items().phantom_data() {
- flags = flags | AdtFlags::IS_PHANTOM_DATA;
- }
- if Some(did) == tcx.lang_items().owned_box() {
- flags = flags | AdtFlags::IS_BOX;
- }
- if Some(did) == tcx.lang_items().arc() {
- flags = flags | AdtFlags::IS_ARC;
- }
- if Some(did) == tcx.lang_items().rc() {
- flags = flags | AdtFlags::IS_RC;
- }
+
if kind == AdtKind::Enum && tcx.has_attr(did, "non_exhaustive") {
debug!("found non-exhaustive variant list for {:?}", did);
flags = flags | AdtFlags::IS_VARIANT_LIST_NON_EXHAUSTIVE;
}
- match kind {
- AdtKind::Enum => flags = flags | AdtFlags::IS_ENUM,
- AdtKind::Union => flags = flags | AdtFlags::IS_UNION,
- AdtKind::Struct => {}
+ flags |= match kind {
+ AdtKind::Enum => AdtFlags::IS_ENUM,
+ AdtKind::Union => AdtFlags::IS_UNION,
+ AdtKind::Struct => AdtFlags::IS_STRUCT,
+ };
+
+ if let AdtKind::Struct = kind {
+ let variant_def = &variants[VariantIdx::new(0)];
+ let def_key = tcx.def_key(variant_def.did);
+ match def_key.disambiguated_data.data {
+ DefPathData::StructCtor => flags |= AdtFlags::HAS_CTOR,
+ _ => (),
+ }
}
+
+ let attrs = tcx.get_attrs(did);
+ if attr::contains_name(&attrs, "fundamental") {
+ flags |= AdtFlags::IS_FUNDAMENTAL;
+ }
+ if Some(did) == tcx.lang_items().phantom_data() {
+ flags |= AdtFlags::IS_PHANTOM_DATA;
+ }
+ if Some(did) == tcx.lang_items().owned_box() {
+ flags |= AdtFlags::IS_BOX;
+ }
+ if Some(did) == tcx.lang_items().arc() {
+ flags |= AdtFlags::IS_ARC;
+ }
+ if Some(did) == tcx.lang_items().rc() {
+ flags |= AdtFlags::IS_RC;
+ }
+
AdtDef {
did,
variants,
@@ -2114,25 +2128,25 @@
#[inline]
pub fn is_struct(&self) -> bool {
- !self.is_union() && !self.is_enum()
+ self.flags.contains(AdtFlags::IS_STRUCT)
}
#[inline]
pub fn is_union(&self) -> bool {
- self.flags.intersects(AdtFlags::IS_UNION)
+ self.flags.contains(AdtFlags::IS_UNION)
}
#[inline]
pub fn is_enum(&self) -> bool {
- self.flags.intersects(AdtFlags::IS_ENUM)
+ self.flags.contains(AdtFlags::IS_ENUM)
}
#[inline]
pub fn is_variant_list_non_exhaustive(&self) -> bool {
- self.flags.intersects(AdtFlags::IS_VARIANT_LIST_NON_EXHAUSTIVE)
+ self.flags.contains(AdtFlags::IS_VARIANT_LIST_NON_EXHAUSTIVE)
}
- /// Returns the kind of the ADT - Struct or Enum.
+ /// Returns the kind of the ADT.
#[inline]
pub fn adt_kind(&self) -> AdtKind {
if self.is_enum() {
@@ -2161,33 +2175,39 @@
}
}
- /// Returns whether this type is #[fundamental] for the purposes
+ /// If this function returns `true`, it implies that `is_struct` must return `true`.
+ #[inline]
+ pub fn has_ctor(&self) -> bool {
+ self.flags.contains(AdtFlags::HAS_CTOR)
+ }
+
+ /// Returns whether this type is `#[fundamental]` for the purposes
/// of coherence checking.
#[inline]
pub fn is_fundamental(&self) -> bool {
- self.flags.intersects(AdtFlags::IS_FUNDAMENTAL)
+ self.flags.contains(AdtFlags::IS_FUNDAMENTAL)
}
/// Returns `true` if this is PhantomData<T>.
#[inline]
pub fn is_phantom_data(&self) -> bool {
- self.flags.intersects(AdtFlags::IS_PHANTOM_DATA)
+ self.flags.contains(AdtFlags::IS_PHANTOM_DATA)
}
/// Returns `true` if this is `Arc<T>`.
pub fn is_arc(&self) -> bool {
- self.flags.intersects(AdtFlags::IS_ARC)
+ self.flags.contains(AdtFlags::IS_ARC)
}
/// Returns `true` if this is `Rc<T>`.
pub fn is_rc(&self) -> bool {
- self.flags.intersects(AdtFlags::IS_RC)
+ self.flags.contains(AdtFlags::IS_RC)
}
/// Returns `true` if this is Box<T>.
#[inline]
pub fn is_box(&self) -> bool {
- self.flags.intersects(AdtFlags::IS_BOX)
+ self.flags.contains(AdtFlags::IS_BOX)
}
/// Returns whether this type has a destructor.
diff --git a/src/librustc_codegen_ssa/mir/place.rs b/src/librustc_codegen_ssa/mir/place.rs
index 1aba532..0a9fbcb 100644
--- a/src/librustc_codegen_ssa/mir/place.rs
+++ b/src/librustc_codegen_ssa/mir/place.rs
@@ -335,11 +335,20 @@
bx: &mut Bx,
llindex: V
) -> Self {
+ // Statically compute the offset if we can, otherwise just use the element size,
+ // as this will yield the lowest alignment.
+ let layout = self.layout.field(bx, 0);
+ let offset = if bx.is_const_integral(llindex) {
+ layout.size.checked_mul(bx.const_to_uint(llindex), bx).unwrap_or(layout.size)
+ } else {
+ layout.size
+ };
+
PlaceRef {
llval: bx.inbounds_gep(self.llval, &[bx.cx().const_usize(0), llindex]),
llextra: None,
- layout: self.layout.field(bx.cx(), 0),
- align: self.align
+ layout,
+ align: self.align.restrict_for_offset(offset),
}
}
diff --git a/src/librustc_codegen_ssa/mir/rvalue.rs b/src/librustc_codegen_ssa/mir/rvalue.rs
index dc7b1ec..a94ee27 100644
--- a/src/librustc_codegen_ssa/mir/rvalue.rs
+++ b/src/librustc_codegen_ssa/mir/rvalue.rs
@@ -131,8 +131,9 @@
let keep_going = header_bx.icmp(IntPredicate::IntNE, current, end);
header_bx.cond_br(keep_going, body_bx.llbb(), next_bx.llbb());
+ let align = dest.align.restrict_for_offset(dest.layout.field(bx.cx(), 0).size);
cg_elem.val.store(&mut body_bx,
- PlaceRef::new_sized(current, cg_elem.layout, dest.align));
+ PlaceRef::new_sized(current, cg_elem.layout, align));
let next = body_bx.inbounds_gep(current, &[bx.cx().const_usize(1)]);
body_bx.br(header_bx.llbb());
diff --git a/src/librustc_mir/borrow_check/nll/type_check/mod.rs b/src/librustc_mir/borrow_check/nll/type_check/mod.rs
index 5f64dfd..2dec217 100644
--- a/src/librustc_mir/borrow_check/nll/type_check/mod.rs
+++ b/src/librustc_mir/borrow_check/nll/type_check/mod.rs
@@ -1415,7 +1415,7 @@
self.check_call_dest(mir, term, &sig, destination, term_location);
self.prove_predicates(
- sig.inputs().iter().map(|ty| ty::Predicate::WellFormed(ty)),
+ sig.inputs_and_output.iter().map(|ty| ty::Predicate::WellFormed(ty)),
term_location.to_locations(),
ConstraintCategory::Boring,
);
diff --git a/src/librustc_mir/interpret/machine.rs b/src/librustc_mir/interpret/machine.rs
index d7a3a27..39e816c 100644
--- a/src/librustc_mir/interpret/machine.rs
+++ b/src/librustc_mir/interpret/machine.rs
@@ -86,7 +86,7 @@
type MemoryExtra: Default;
/// Extra data stored in every allocation.
- type AllocExtra: AllocationExtra<Self::PointerTag, Self::MemoryExtra>;
+ type AllocExtra: AllocationExtra<Self::PointerTag, Self::MemoryExtra> + 'static;
/// Memory's allocation map
type MemoryMap:
diff --git a/src/librustc_mir/interpret/memory.rs b/src/librustc_mir/interpret/memory.rs
index 97d7e15..1260fda 100644
--- a/src/librustc_mir/interpret/memory.rs
+++ b/src/librustc_mir/interpret/memory.rs
@@ -708,8 +708,13 @@
relocations
.iter()
.map(|&(offset, reloc)| {
- (offset + dest.offset - src.offset + (i * size * relocations.len() as u64),
- reloc)
+ // compute offset for current repetition
+ let dest_offset = dest.offset + (i * size);
+ (
+ // shift offsets from source allocation to destination allocation
+ offset + dest_offset - src.offset,
+ reloc,
+ )
})
);
}
diff --git a/src/librustc_mir/transform/qualify_consts.rs b/src/librustc_mir/transform/qualify_consts.rs
index bcee6d7..bc0feb1 100644
--- a/src/librustc_mir/transform/qualify_consts.rs
+++ b/src/librustc_mir/transform/qualify_consts.rs
@@ -517,7 +517,7 @@
// Only allow statics (not consts) to refer to other statics.
if self.mode == Mode::Static || self.mode == Mode::StaticMut {
- if context.is_mutating_use() {
+ if self.mode == Mode::Static && context.is_mutating_use() {
// this is not strictly necessary as miri will also bail out
// For interior mutability we can't really catch this statically as that
// goes through raw pointers and intermediate temporaries, so miri has
diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs
index fdac1e3..e39c764 100644
--- a/src/librustc_resolve/lib.rs
+++ b/src/librustc_resolve/lib.rs
@@ -1022,11 +1022,11 @@
CurrentScope,
}
-impl<'a> PartialEq for ModuleOrUniformRoot<'a> {
- fn eq(&self, other: &Self) -> bool {
- match (*self, *other) {
+impl ModuleOrUniformRoot<'_> {
+ fn same_def(lhs: Self, rhs: Self) -> bool {
+ match (lhs, rhs) {
(ModuleOrUniformRoot::Module(lhs),
- ModuleOrUniformRoot::Module(rhs)) => ptr::eq(lhs, rhs),
+ ModuleOrUniformRoot::Module(rhs)) => lhs.def() == rhs.def(),
(ModuleOrUniformRoot::CrateRootAndExternPrelude,
ModuleOrUniformRoot::CrateRootAndExternPrelude) |
(ModuleOrUniformRoot::ExternPrelude, ModuleOrUniformRoot::ExternPrelude) |
diff --git a/src/librustc_resolve/resolve_imports.rs b/src/librustc_resolve/resolve_imports.rs
index e7cd32f..ddcaf54 100644
--- a/src/librustc_resolve/resolve_imports.rs
+++ b/src/librustc_resolve/resolve_imports.rs
@@ -465,6 +465,10 @@
self.set_binding_parent_module(binding, module);
self.update_resolution(module, ident, ns, |this, resolution| {
if let Some(old_binding) = resolution.binding {
+ if binding.def() == Def::Err {
+ // Do not override real bindings with `Def::Err`s from error recovery.
+ return Ok(());
+ }
match (old_binding.is_glob_import(), binding.is_glob_import()) {
(true, true) => {
if binding.def() != old_binding.def() {
@@ -836,7 +840,9 @@
PathResult::Module(module) => {
// Consistency checks, analogous to `finalize_current_module_macro_resolutions`.
if let Some(initial_module) = directive.imported_module.get() {
- if module != initial_module && self.ambiguity_errors.is_empty() {
+ if !ModuleOrUniformRoot::same_def(module, initial_module)
+ && self.ambiguity_errors.is_empty()
+ {
span_bug!(directive.span, "inconsistent resolution for an import");
}
} else {
diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs
index 4fbbe58..dd9b9ce 100644
--- a/src/librustc_typeck/astconv.rs
+++ b/src/librustc_typeck/astconv.rs
@@ -1013,6 +1013,7 @@
let mut associated_types = BTreeSet::default();
for tr in traits::elaborate_trait_ref(tcx, principal) {
+ debug!("conv_object_ty_poly_trait_ref: observing object predicate `{:?}`", tr);
match tr {
ty::Predicate::Trait(pred) => {
associated_types.extend(tcx.associated_items(pred.def_id())
@@ -1020,8 +1021,31 @@
.map(|item| item.def_id));
}
ty::Predicate::Projection(pred) => {
- // Include projections defined on supertraits.
- projection_bounds.push((pred, DUMMY_SP))
+ // A `Self` within the original bound will be substituted with a
+ // `TRAIT_OBJECT_DUMMY_SELF`, so check for that.
+ let references_self =
+ pred.skip_binder().ty.walk().any(|t| t == dummy_self);
+
+ // If the projection output contains `Self`, force the user to
+ // elaborate it explicitly to avoid a bunch of complexity.
+ //
+ // The "classicaly useful" case is the following:
+ // ```
+ // trait MyTrait: FnMut() -> <Self as MyTrait>::MyOutput {
+ // type MyOutput;
+ // }
+ // ```
+ //
+ // Here, the user could theoretically write `dyn MyTrait<Output=X>`,
+ // but actually supporting that would "expand" to an infinitely-long type
+ // `fix $ τ → dyn MyTrait<MyOutput=X, Output=<τ as MyTrait>::MyOutput`.
+ //
+ // Instead, we force the user to write `dyn MyTrait<MyOutput=X, Output=X>`,
+ // which is uglier but works. See the discussion in #56288 for alternatives.
+ if !references_self {
+ // Include projections defined on supertraits,
+ projection_bounds.push((pred, DUMMY_SP))
+ }
}
_ => ()
}
diff --git a/src/librustc_typeck/check/callee.rs b/src/librustc_typeck/check/callee.rs
index 7a71cf5..3ed1ab2 100644
--- a/src/librustc_typeck/check/callee.rs
+++ b/src/librustc_typeck/check/callee.rs
@@ -280,7 +280,7 @@
Def::Local(id) | Def::Upvar(id, ..) => {
Some(self.tcx.hir.span(id))
}
- _ => self.tcx.hir.span_if_local(def.def_id())
+ _ => def.opt_def_id().and_then(|did| self.tcx.hir.span_if_local(did)),
};
if let Some(span) = def_span {
let label = match (unit_variant, inner_callee_path) {
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
index a107cec..c7e9239 100644
--- a/src/librustc_typeck/check/mod.rs
+++ b/src/librustc_typeck/check/mod.rs
@@ -98,7 +98,8 @@
use rustc::ty::subst::{CanonicalUserSubsts, UnpackedKind, Subst, Substs,
UserSelfTy, UserSubsts};
use rustc::traits::{self, ObligationCause, ObligationCauseCode, TraitEngine};
-use rustc::ty::{self, Ty, TyCtxt, GenericParamDefKind, Visibility, ToPredicate, RegionKind};
+use rustc::ty::{self, AdtKind, Ty, TyCtxt, GenericParamDefKind, Visibility, ToPredicate,
+ RegionKind};
use rustc::ty::adjustment::{Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability};
use rustc::ty::fold::TypeFoldable;
use rustc::ty::query::Providers;
@@ -3222,8 +3223,8 @@
return_expr_ty);
}
- // A generic function for checking the then and else in an if
- // or if-else.
+ // A generic function for checking the 'then' and 'else' clauses in an 'if'
+ // or 'if-else' expression.
fn check_then_else(&self,
cond_expr: &'gcx hir::Expr,
then_expr: &'gcx hir::Expr,
@@ -3548,8 +3549,8 @@
// we don't look at stability attributes on
// struct-like enums (yet...), but it's definitely not
- // a bug to have construct one.
- if adt_kind != ty::AdtKind::Enum {
+ // a bug to have constructed one.
+ if adt_kind != AdtKind::Enum {
tcx.check_stability(v_field.did, Some(expr_id), field.span);
}
@@ -5161,26 +5162,48 @@
}).unwrap_or(false);
let mut new_def = def;
- let (def_id, ty) = if let Def::SelfCtor(impl_def_id) = def {
- let ty = self.impl_self_ty(span, impl_def_id).ty;
+ let (def_id, ty) = match def {
+ Def::SelfCtor(impl_def_id) => {
+ let ty = self.impl_self_ty(span, impl_def_id).ty;
+ let adt_def = ty.ty_adt_def();
- match ty.ty_adt_def() {
- Some(adt_def) if adt_def.is_struct() => {
- let variant = adt_def.non_enum_variant();
- new_def = Def::StructCtor(variant.did, variant.ctor_kind);
- (variant.did, self.tcx.type_of(variant.did))
- }
- _ => {
- (impl_def_id, self.tcx.types.err)
+ match adt_def {
+ Some(adt_def) if adt_def.has_ctor() => {
+ let variant = adt_def.non_enum_variant();
+ new_def = Def::StructCtor(variant.did, variant.ctor_kind);
+ (variant.did, self.tcx.type_of(variant.did))
+ }
+ _ => {
+ let mut err = self.tcx.sess.struct_span_err(span,
+ "the `Self` constructor can only be used with tuple or unit structs");
+ if let Some(adt_def) = adt_def {
+ match adt_def.adt_kind() {
+ AdtKind::Enum => {
+ err.note("did you mean to use one of the enum's variants?");
+ },
+ AdtKind::Struct |
+ AdtKind::Union => {
+ err.span_label(
+ span,
+ format!("did you mean `Self {{ /* fields */ }}`?"),
+ );
+ }
+ }
+ }
+ err.emit();
+
+ (impl_def_id, self.tcx.types.err)
+ }
}
}
- } else {
- let def_id = def.def_id();
+ _ => {
+ let def_id = def.def_id();
- // The things we are substituting into the type should not contain
- // escaping late-bound regions, and nor should the base type scheme.
- let ty = self.tcx.type_of(def_id);
- (def_id, ty)
+ // The things we are substituting into the type should not contain
+ // escaping late-bound regions, and nor should the base type scheme.
+ let ty = self.tcx.type_of(def_id);
+ (def_id, ty)
+ }
};
let substs = AstConv::create_substs_for_generic_args(
diff --git a/src/stage0.txt b/src/stage0.txt
index b0ef7b6..2b089c0 100644
--- a/src/stage0.txt
+++ b/src/stage0.txt
@@ -12,8 +12,8 @@
# source tarball for a stable release you'll likely see `1.x.0` for rustc and
# `0.x.0` for Cargo where they were released on `date`.
-date: 2018-12-06
-rustc: 1.31.0
+date: 2018-12-20
+rustc: 1.31.1
cargo: 0.32.0
# When making a stable release the process currently looks like:
diff --git a/src/test/codegen/issue-56927.rs b/src/test/codegen/issue-56927.rs
new file mode 100644
index 0000000..0544ff8
--- /dev/null
+++ b/src/test/codegen/issue-56927.rs
@@ -0,0 +1,44 @@
+// compile-flags: -C no-prepopulate-passes
+
+#![crate_type="rlib"]
+use std::usize;
+
+#[repr(align(16))]
+pub struct S {
+ arr: [u32; 4],
+}
+
+// CHECK-LABEL: @test1
+// CHECK: store i32 0, i32* %{{.+}}, align 16
+// CHECK: store i32 1, i32* %{{.+}}, align 4
+// CHECK: store i32 2, i32* %{{.+}}, align 8
+// CHECK: store i32 3, i32* %{{.+}}, align 4
+#[no_mangle]
+pub fn test1(s: &mut S) {
+ s.arr[0] = 0;
+ s.arr[1] = 1;
+ s.arr[2] = 2;
+ s.arr[3] = 3;
+}
+
+// CHECK-LABEL: @test2
+// CHECK: store i32 4, i32* %{{.+}}, align 4
+#[allow(const_err)]
+#[no_mangle]
+pub fn test2(s: &mut S) {
+ s.arr[usize::MAX / 4 + 1] = 4;
+}
+
+// CHECK-LABEL: @test3
+// CHECK: store i32 5, i32* %{{.+}}, align 4
+#[no_mangle]
+pub fn test3(s: &mut S, i: usize) {
+ s.arr[i] = 5;
+}
+
+// CHECK-LABEL: @test4
+// CHECK: store i32 6, i32* %{{.+}}, align 4
+#[no_mangle]
+pub fn test4(s: &mut S) {
+ s.arr = [6; 4];
+}
diff --git a/src/test/codegen/packed.rs b/src/test/codegen/packed.rs
index b50f5b6..e60051d 100644
--- a/src/test/codegen/packed.rs
+++ b/src/test/codegen/packed.rs
@@ -84,6 +84,42 @@
BigPacked2 { dealign: 0, data: f() }
}
+// CHECK-LABEL: @write_packed_array1
+// CHECK: store i32 0, i32* %{{.+}}, align 1
+// CHECK: store i32 1, i32* %{{.+}}, align 1
+// CHECK: store i32 2, i32* %{{.+}}, align 1
+#[no_mangle]
+pub fn write_packed_array1(p: &mut BigPacked1) {
+ p.data.0[0] = 0;
+ p.data.0[1] = 1;
+ p.data.0[2] = 2;
+}
+
+// CHECK-LABEL: @write_packed_array2
+// CHECK: store i32 0, i32* %{{.+}}, align 2
+// CHECK: store i32 1, i32* %{{.+}}, align 2
+// CHECK: store i32 2, i32* %{{.+}}, align 2
+#[no_mangle]
+pub fn write_packed_array2(p: &mut BigPacked2) {
+ p.data.0[0] = 0;
+ p.data.0[1] = 1;
+ p.data.0[2] = 2;
+}
+
+// CHECK-LABEL: @repeat_packed_array1
+// CHECK: store i32 42, i32* %{{.+}}, align 1
+#[no_mangle]
+pub fn repeat_packed_array1(p: &mut BigPacked1) {
+ p.data.0 = [42; 8];
+}
+
+// CHECK-LABEL: @repeat_packed_array2
+// CHECK: store i32 42, i32* %{{.+}}, align 2
+#[no_mangle]
+pub fn repeat_packed_array2(p: &mut BigPacked2) {
+ p.data.0 = [42; 8];
+}
+
#[repr(packed)]
#[derive(Copy, Clone)]
pub struct Packed1Pair(u8, u32);
diff --git a/src/test/rustdoc/issue-50159.rs b/src/test/rustdoc/issue-50159.rs
new file mode 100644
index 0000000..3055c72
--- /dev/null
+++ b/src/test/rustdoc/issue-50159.rs
@@ -0,0 +1,31 @@
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+
+pub trait Signal {
+ type Item;
+}
+
+pub trait Signal2 {
+ type Item2;
+}
+
+impl<B, C> Signal2 for B where B: Signal<Item = C> {
+ type Item2 = C;
+}
+
+// @has issue_50159/struct.Switch.html
+// @has - '//code' 'impl<B> Send for Switch<B> where <B as Signal>::Item: Send'
+// @has - '//code' 'impl<B> Sync for Switch<B> where <B as Signal>::Item: Sync'
+// @count - '//*[@id="implementations-list"]/*[@class="impl"]' 0
+// @count - '//*[@id="synthetic-implementations-list"]/*[@class="impl"]' 2
+pub struct Switch<B: Signal> {
+ pub inner: <B as Signal2>::Item2,
+}
diff --git a/src/test/rustdoc/issue-56822.rs b/src/test/rustdoc/issue-56822.rs
new file mode 100644
index 0000000..41aba1a
--- /dev/null
+++ b/src/test/rustdoc/issue-56822.rs
@@ -0,0 +1,34 @@
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+struct Wrapper<T>(T);
+
+trait MyTrait {
+ type Output;
+}
+
+impl<'a, I, T: 'a> MyTrait for Wrapper<I>
+ where I: MyTrait<Output=&'a T>
+{
+ type Output = T;
+}
+
+struct Inner<'a, T>(&'a T);
+
+impl<'a, T> MyTrait for Inner<'a, T> {
+ type Output = &'a T;
+}
+
+// @has issue_56822/struct.Parser.html
+// @has - '//*[@id="synthetic-implementations-list"]/*[@class="impl"]//*/code' "impl<'a> Send for \
+// Parser<'a>"
+pub struct Parser<'a> {
+ field: <Wrapper<Inner<'a, u8>> as MyTrait>::Output
+}
diff --git a/src/test/rustdoc/synthetic_auto/self-referential.rs b/src/test/rustdoc/synthetic_auto/self-referential.rs
new file mode 100644
index 0000000..516a3c9
--- /dev/null
+++ b/src/test/rustdoc/synthetic_auto/self-referential.rs
@@ -0,0 +1,40 @@
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Some unusual code minimized from
+// https://github.com/sile/handy_async/tree/7b619b762c06544fc67792c8ff8ebc24a88fdb98
+
+pub trait Pattern {
+ type Value;
+}
+
+pub struct Constrain<A, B = A, C = A>(A, B, C);
+
+impl<A, B, C> Pattern for Constrain<A, B, C>
+ where A: Pattern,
+ B: Pattern<Value = A::Value>,
+ C: Pattern<Value = A::Value>,
+{
+ type Value = A::Value;
+}
+
+pub struct Wrapper<T>(T);
+
+impl<T> Pattern for Wrapper<T> {
+ type Value = T;
+}
+
+
+// @has self_referential/struct.WriteAndThen.html
+// @has - '//*[@id="synthetic-implementations-list"]/*[@class="impl"]//*/code' "impl<P1> Send for \
+// WriteAndThen<P1> where <P1 as Pattern>::Value: Send"
+pub struct WriteAndThen<P1>(pub P1::Value,pub <Constrain<P1, Wrapper<P1::Value>> as Pattern>::Value)
+ where P1: Pattern;
+
diff --git a/src/test/ui/consts/promoted_regression.rs b/src/test/ui/consts/promoted_regression.rs
new file mode 100644
index 0000000..68b9a20
--- /dev/null
+++ b/src/test/ui/consts/promoted_regression.rs
@@ -0,0 +1,9 @@
+// compile-pass
+
+fn main() {
+ let _ = &[("", ""); 3];
+}
+
+const FOO: &[(&str, &str)] = &[("", ""); 3];
+const BAR: &[(&str, &str); 5] = &[("", ""); 5];
+const BAA: &[[&str; 12]; 11] = &[[""; 12]; 11];
diff --git a/src/test/ui/consts/static_mut_containing_mut_ref.rs b/src/test/ui/consts/static_mut_containing_mut_ref.rs
new file mode 100644
index 0000000..27e1a11
--- /dev/null
+++ b/src/test/ui/consts/static_mut_containing_mut_ref.rs
@@ -0,0 +1,7 @@
+// compile-pass
+
+static mut STDERR_BUFFER_SPACE: [u8; 42] = [0u8; 42];
+
+pub static mut STDERR_BUFFER: *mut [u8] = unsafe { &mut STDERR_BUFFER_SPACE };
+
+fn main() {}
diff --git a/src/test/ui/consts/static_mut_containing_mut_ref2.rs b/src/test/ui/consts/static_mut_containing_mut_ref2.rs
new file mode 100644
index 0000000..aeb69b2
--- /dev/null
+++ b/src/test/ui/consts/static_mut_containing_mut_ref2.rs
@@ -0,0 +1,8 @@
+#![feature(const_let)]
+
+static mut STDERR_BUFFER_SPACE: u8 = 0;
+
+pub static mut STDERR_BUFFER: () = unsafe { *(&mut STDERR_BUFFER_SPACE) = 42; };
+//~^ ERROR references in statics may only refer to immutable values
+
+fn main() {}
diff --git a/src/test/ui/consts/static_mut_containing_mut_ref2.stderr b/src/test/ui/consts/static_mut_containing_mut_ref2.stderr
new file mode 100644
index 0000000..7292343
--- /dev/null
+++ b/src/test/ui/consts/static_mut_containing_mut_ref2.stderr
@@ -0,0 +1,9 @@
+error[E0017]: references in statics may only refer to immutable values
+ --> $DIR/static_mut_containing_mut_ref2.rs:5:46
+ |
+LL | pub static mut STDERR_BUFFER: () = unsafe { *(&mut STDERR_BUFFER_SPACE) = 42; };
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^ statics require immutable values
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0017`.
diff --git a/src/test/ui/consts/static_mut_containing_mut_ref3.rs b/src/test/ui/consts/static_mut_containing_mut_ref3.rs
new file mode 100644
index 0000000..0bc7faa
--- /dev/null
+++ b/src/test/ui/consts/static_mut_containing_mut_ref3.rs
@@ -0,0 +1,8 @@
+#![feature(const_let)]
+
+static mut FOO: (u8, u8) = (42, 43);
+
+static mut BAR: () = unsafe { FOO.0 = 99; };
+//~^ ERROR could not evaluate static initializer
+
+fn main() {}
diff --git a/src/test/ui/consts/static_mut_containing_mut_ref3.stderr b/src/test/ui/consts/static_mut_containing_mut_ref3.stderr
new file mode 100644
index 0000000..cae53c6
--- /dev/null
+++ b/src/test/ui/consts/static_mut_containing_mut_ref3.stderr
@@ -0,0 +1,9 @@
+error[E0080]: could not evaluate static initializer
+ --> $DIR/static_mut_containing_mut_ref3.rs:5:31
+ |
+LL | static mut BAR: () = unsafe { FOO.0 = 99; };
+ | ^^^^^^^^^^ tried to modify a static's initial value from another static's initializer
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0080`.
diff --git a/src/test/ui/imports/duplicate.rs b/src/test/ui/imports/duplicate.rs
index dd2dcbe..aad5529 100644
--- a/src/test/ui/imports/duplicate.rs
+++ b/src/test/ui/imports/duplicate.rs
@@ -43,7 +43,7 @@
fn main() {
e::foo();
f::foo(); //~ ERROR `foo` is ambiguous
- g::foo(); //~ ERROR `foo` is ambiguous
+ g::foo();
}
mod ambiguous_module_errors {
diff --git a/src/test/ui/imports/duplicate.stderr b/src/test/ui/imports/duplicate.stderr
index f53ba9c..b4b3fc2 100644
--- a/src/test/ui/imports/duplicate.stderr
+++ b/src/test/ui/imports/duplicate.stderr
@@ -51,25 +51,6 @@
= help: consider adding an explicit import of `foo` to disambiguate
error[E0659]: `foo` is ambiguous (glob import vs glob import in the same module)
- --> $DIR/duplicate.rs:46:8
- |
-LL | g::foo(); //~ ERROR `foo` is ambiguous
- | ^^^ ambiguous name
- |
-note: `foo` could refer to the function imported here
- --> $DIR/duplicate.rs:39:13
- |
-LL | pub use a::*;
- | ^^^^
- = help: consider adding an explicit import of `foo` to disambiguate
-note: `foo` could also refer to the unresolved item imported here
- --> $DIR/duplicate.rs:40:13
- |
-LL | pub use f::*;
- | ^^^^
- = help: consider adding an explicit import of `foo` to disambiguate
-
-error[E0659]: `foo` is ambiguous (glob import vs glob import in the same module)
--> $DIR/duplicate.rs:59:9
|
LL | foo::bar(); //~ ERROR `foo` is ambiguous
@@ -88,7 +69,7 @@
| ^^^^^^^^^^^
= help: consider adding an explicit import of `foo` to disambiguate
-error: aborting due to 5 previous errors
+error: aborting due to 4 previous errors
Some errors occurred: E0252, E0659.
For more information about an error, try `rustc --explain E0252`.
diff --git a/src/test/ui/imports/issue-56125.stderr b/src/test/ui/imports/issue-56125.stderr
index b1292ef..72d6041 100644
--- a/src/test/ui/imports/issue-56125.stderr
+++ b/src/test/ui/imports/issue-56125.stderr
@@ -54,12 +54,12 @@
|
= note: `issue_56125` could refer to an extern crate passed with `--extern`
= help: use `::issue_56125` to refer to this extern crate unambiguously
-note: `issue_56125` could also refer to the unresolved item imported here
- --> $DIR/issue-56125.rs:21:9
+note: `issue_56125` could also refer to the module imported here
+ --> $DIR/issue-56125.rs:22:9
|
-LL | use empty::issue_56125; //~ ERROR unresolved import `empty::issue_56125`
- | ^^^^^^^^^^^^^^^^^^
- = help: use `self::issue_56125` to refer to this unresolved item unambiguously
+LL | use issue_56125::*; //~ ERROR `issue_56125` is ambiguous
+ | ^^^^^^^^^^^^^^
+ = help: use `self::issue_56125` to refer to this module unambiguously
error: aborting due to 6 previous errors
diff --git a/src/test/ui/imports/issue-57015.rs b/src/test/ui/imports/issue-57015.rs
new file mode 100644
index 0000000..27688fd
--- /dev/null
+++ b/src/test/ui/imports/issue-57015.rs
@@ -0,0 +1,13 @@
+mod glob_ok {
+ pub mod something {
+ pub mod something_else {}
+ }
+}
+
+mod single_err {}
+
+use glob_ok::*; // glob_ok::something
+use single_err::something; //~ ERROR unresolved import `single_err::something`
+use something::something_else;
+
+fn main() {}
diff --git a/src/test/ui/imports/issue-57015.stderr b/src/test/ui/imports/issue-57015.stderr
new file mode 100644
index 0000000..b0fcf5b
--- /dev/null
+++ b/src/test/ui/imports/issue-57015.stderr
@@ -0,0 +1,9 @@
+error[E0432]: unresolved import `single_err::something`
+ --> $DIR/issue-57015.rs:10:5
+ |
+LL | use single_err::something; //~ ERROR unresolved import `single_err::something`
+ | ^^^^^^^^^^^^^^^^^^^^^ no `something` in `single_err`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0432`.
diff --git a/src/test/ui/issues/issue-56199.rs b/src/test/ui/issues/issue-56199.rs
new file mode 100644
index 0000000..83d4e31
--- /dev/null
+++ b/src/test/ui/issues/issue-56199.rs
@@ -0,0 +1,23 @@
+
+enum Foo {}
+struct Bar {}
+
+impl Foo {
+ fn foo() {
+ let _ = Self;
+ //~^ ERROR the `Self` constructor can only be used with tuple or unit structs
+ let _ = Self();
+ //~^ ERROR the `Self` constructor can only be used with tuple or unit structs
+ }
+}
+
+impl Bar {
+ fn bar() {
+ let _ = Self;
+ //~^ ERROR the `Self` constructor can only be used with tuple or unit structs
+ let _ = Self();
+ //~^ ERROR the `Self` constructor can only be used with tuple or unit structs
+ }
+}
+
+fn main() {}
diff --git a/src/test/ui/issues/issue-56199.stderr b/src/test/ui/issues/issue-56199.stderr
new file mode 100644
index 0000000..6e3c7fd
--- /dev/null
+++ b/src/test/ui/issues/issue-56199.stderr
@@ -0,0 +1,30 @@
+error: the `Self` constructor can only be used with tuple or unit structs
+ --> $DIR/issue-56199.rs:7:17
+ |
+LL | let _ = Self;
+ | ^^^^
+ |
+ = note: did you mean to use one of the enum's variants?
+
+error: the `Self` constructor can only be used with tuple or unit structs
+ --> $DIR/issue-56199.rs:9:17
+ |
+LL | let _ = Self();
+ | ^^^^
+ |
+ = note: did you mean to use one of the enum's variants?
+
+error: the `Self` constructor can only be used with tuple or unit structs
+ --> $DIR/issue-56199.rs:16:17
+ |
+LL | let _ = Self;
+ | ^^^^ did you mean `Self { /* fields */ }`?
+
+error: the `Self` constructor can only be used with tuple or unit structs
+ --> $DIR/issue-56199.rs:18:17
+ |
+LL | let _ = Self();
+ | ^^^^ did you mean `Self { /* fields */ }`?
+
+error: aborting due to 4 previous errors
+
diff --git a/src/test/ui/issues/issue-56835.rs b/src/test/ui/issues/issue-56835.rs
new file mode 100644
index 0000000..c16550e
--- /dev/null
+++ b/src/test/ui/issues/issue-56835.rs
@@ -0,0 +1,10 @@
+
+pub struct Foo {}
+
+impl Foo {
+ fn bar(Self(foo): Self) {}
+ //~^ ERROR the `Self` constructor can only be used with tuple or unit structs
+ //~^^ ERROR expected tuple struct/variant, found self constructor `Self` [E0164]
+}
+
+fn main() {}
diff --git a/src/test/ui/issues/issue-56835.stderr b/src/test/ui/issues/issue-56835.stderr
new file mode 100644
index 0000000..b7c3b14
--- /dev/null
+++ b/src/test/ui/issues/issue-56835.stderr
@@ -0,0 +1,15 @@
+error: the `Self` constructor can only be used with tuple or unit structs
+ --> $DIR/issue-56835.rs:5:12
+ |
+LL | fn bar(Self(foo): Self) {}
+ | ^^^^^^^^^ did you mean `Self { /* fields */ }`?
+
+error[E0164]: expected tuple struct/variant, found self constructor `Self`
+ --> $DIR/issue-56835.rs:5:12
+ |
+LL | fn bar(Self(foo): Self) {}
+ | ^^^^^^^^^ not a tuple variant or struct
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0164`.
diff --git a/src/test/ui/nll/issue-57265-return-type-wf-check.rs b/src/test/ui/nll/issue-57265-return-type-wf-check.rs
new file mode 100644
index 0000000..24c61a4
--- /dev/null
+++ b/src/test/ui/nll/issue-57265-return-type-wf-check.rs
@@ -0,0 +1,26 @@
+#![feature(nll)]
+
+use std::any::Any;
+
+#[derive(Debug, Clone)]
+struct S<T: 'static>(T);
+
+// S<&'a T> is in the return type, so we get an implied bound
+// &'a T: 'static
+fn foo<'a, T>(x: &'a T) -> (S<&'a T>, Box<dyn Any + 'static>) {
+ let y = S(x);
+
+ let z = Box::new(y.clone()) as Box<dyn Any + 'static>;
+ (y, z)
+}
+
+fn main() {
+ let x = 5;
+
+ // Check that we require that the argument is of type `&'static String`,
+ // so that the return type is well-formed.
+ let (_, z) = foo(&"hello".to_string());
+ //~^ ERROR temporary value dropped while borrowed
+
+ println!("{:?}", z.downcast_ref::<S<&'static String>>());
+}
diff --git a/src/test/ui/nll/issue-57265-return-type-wf-check.stderr b/src/test/ui/nll/issue-57265-return-type-wf-check.stderr
new file mode 100644
index 0000000..db01212
--- /dev/null
+++ b/src/test/ui/nll/issue-57265-return-type-wf-check.stderr
@@ -0,0 +1,12 @@
+error[E0716]: temporary value dropped while borrowed
+ --> $DIR/issue-57265-return-type-wf-check.rs:22:23
+ |
+LL | let (_, z) = foo(&"hello".to_string());
+ | -----^^^^^^^^^^^^^^^^^^^-- temporary value is freed at the end of this statement
+ | | |
+ | | creates a temporary which is freed while still in use
+ | argument requires that borrow lasts for `'static`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0716`.
diff --git a/src/test/ui/rust-2018/uniform-paths/auxiliary/issue-56596-2.rs b/src/test/ui/rust-2018/uniform-paths/auxiliary/issue-56596-2.rs
new file mode 100644
index 0000000..db72307
--- /dev/null
+++ b/src/test/ui/rust-2018/uniform-paths/auxiliary/issue-56596-2.rs
@@ -0,0 +1 @@
+pub extern crate core;
diff --git a/src/test/ui/rust-2018/uniform-paths/issue-56596-2.rs b/src/test/ui/rust-2018/uniform-paths/issue-56596-2.rs
new file mode 100644
index 0000000..9ec3a64
--- /dev/null
+++ b/src/test/ui/rust-2018/uniform-paths/issue-56596-2.rs
@@ -0,0 +1,11 @@
+// compile-pass
+// edition:2018
+// compile-flags: --extern issue_56596_2
+// aux-build:issue-56596-2.rs
+
+mod m {
+ use core::any;
+ pub use issue_56596_2::*;
+}
+
+fn main() {}
diff --git a/src/test/ui/traits/trait-object-with-self-in-projection-output-bad.rs b/src/test/ui/traits/trait-object-with-self-in-projection-output-bad.rs
new file mode 100644
index 0000000..766bd14
--- /dev/null
+++ b/src/test/ui/traits/trait-object-with-self-in-projection-output-bad.rs
@@ -0,0 +1,50 @@
+// Regression test for #56288. Checks that if a supertrait defines an associated type
+// projection that references `Self`, then that associated type must still be explicitly
+// specified in the `dyn Trait` variant, since we don't know what `Self` is anymore.
+
+trait Base {
+ type Output;
+}
+
+trait Helper: Base<Output=<Self as Helper>::Target> {
+ type Target;
+}
+
+impl Base for u32
+{
+ type Output = i32;
+}
+
+impl Helper for u32
+{
+ type Target = i32;
+}
+
+trait ConstI32 {
+ type Out;
+}
+
+impl<T: ?Sized> ConstI32 for T {
+ type Out = i32;
+}
+
+// Test that you still need to manually give a projection type if the Output type
+// is normalizable.
+trait NormalizableHelper:
+ Base<Output=<Self as ConstI32>::Out>
+{
+ type Target;
+}
+
+impl NormalizableHelper for u32
+{
+ type Target = i32;
+}
+
+fn main() {
+ let _x: Box<dyn Helper<Target=i32>> = Box::new(2u32);
+ //~^ ERROR the value of the associated type `Output` (from the trait `Base`) must be specified
+
+ let _y: Box<dyn NormalizableHelper<Target=i32>> = Box::new(2u32);
+ //~^ ERROR the value of the associated type `Output` (from the trait `Base`) must be specified
+}
diff --git a/src/test/ui/traits/trait-object-with-self-in-projection-output-bad.stderr b/src/test/ui/traits/trait-object-with-self-in-projection-output-bad.stderr
new file mode 100644
index 0000000..350f8ea
--- /dev/null
+++ b/src/test/ui/traits/trait-object-with-self-in-projection-output-bad.stderr
@@ -0,0 +1,21 @@
+error[E0191]: the value of the associated type `Output` (from the trait `Base`) must be specified
+ --> $DIR/trait-object-with-self-in-projection-output-bad.rs:45:17
+ |
+LL | type Output;
+ | ------------ `Output` defined here
+...
+LL | let _x: Box<dyn Helper<Target=i32>> = Box::new(2u32);
+ | ^^^^^^^^^^^^^^^^^^^^^^ associated type `Output` must be specified
+
+error[E0191]: the value of the associated type `Output` (from the trait `Base`) must be specified
+ --> $DIR/trait-object-with-self-in-projection-output-bad.rs:48:17
+ |
+LL | type Output;
+ | ------------ `Output` defined here
+...
+LL | let _y: Box<dyn NormalizableHelper<Target=i32>> = Box::new(2u32);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ associated type `Output` must be specified
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0191`.
diff --git a/src/test/ui/traits/trait-object-with-self-in-projection-output-good.rs b/src/test/ui/traits/trait-object-with-self-in-projection-output-good.rs
new file mode 100644
index 0000000..793d556
--- /dev/null
+++ b/src/test/ui/traits/trait-object-with-self-in-projection-output-good.rs
@@ -0,0 +1,28 @@
+// compile-pass
+
+// Regression test related to #56288. Check that a supertrait projection (of
+// `Output`) that references `Self` can be ok if it is referencing a projection (of
+// `Self::Target`, in this case). Note that we still require the user to manually
+// specify both `Target` and `Output` for now.
+
+trait Base {
+ type Output;
+}
+
+trait Helper: Base<Output=<Self as Helper>::Target> {
+ type Target;
+}
+
+impl Base for u32
+{
+ type Output = i32;
+}
+
+impl Helper for u32
+{
+ type Target = i32;
+}
+
+fn main() {
+ let _x: Box<dyn Helper<Target=i32, Output=i32>> = Box::new(2u32);
+}
diff --git a/src/test/ui/traits/trait-object-with-self-in-projection-output-repeated-supertrait.rs b/src/test/ui/traits/trait-object-with-self-in-projection-output-repeated-supertrait.rs
new file mode 100644
index 0000000..46c083f
--- /dev/null
+++ b/src/test/ui/traits/trait-object-with-self-in-projection-output-repeated-supertrait.rs
@@ -0,0 +1,48 @@
+// compile-pass
+
+// Regression test related to #56288. Check that a supertrait projection (of
+// `Output`) that references `Self` is ok if there is another occurence of
+// the same supertrait that specifies the projection explicitly, even if
+// the projection's associated type is not explicitly specified in the object type.
+//
+// Note that in order for this to compile, we need the `Self`-referencing projection
+// to normalize fairly directly to a concrete type, otherwise the trait resolver
+// will hate us.
+//
+// There is a test in `trait-object-with-self-in-projection-output-bad.rs` that
+// having a normalizing, but `Self`-containing projection does not *by itself*
+// allow you to avoid writing the projected type (`Output`, in this example)
+// explicitly.
+
+trait ConstI32 {
+ type Out;
+}
+
+impl<T: ?Sized> ConstI32 for T {
+ type Out = i32;
+}
+
+trait Base {
+ type Output;
+}
+
+trait NormalizingHelper: Base<Output=<Self as ConstI32>::Out> + Base<Output=i32> {
+ type Target;
+}
+
+impl Base for u32
+{
+ type Output = i32;
+}
+
+impl NormalizingHelper for u32
+{
+ type Target = i32;
+}
+
+fn main() {
+ // Make sure this works both with and without the associated type
+ // being specified.
+ let _x: Box<dyn NormalizingHelper<Target=i32>> = Box::new(2u32);
+ let _y: Box<dyn NormalizingHelper<Target=i32, Output=i32>> = Box::new(2u32);
+}
diff --git a/src/test/ui/write-to-static-mut-in-static.rs b/src/test/ui/write-to-static-mut-in-static.rs
index 191f09b..983b5d4 100644
--- a/src/test/ui/write-to-static-mut-in-static.rs
+++ b/src/test/ui/write-to-static-mut-in-static.rs
@@ -12,10 +12,10 @@
pub static mut A: u32 = 0;
pub static mut B: () = unsafe { A = 1; };
-//~^ ERROR cannot mutate statics in the initializer of another static
+//~^ ERROR could not evaluate static initializer
pub static mut C: u32 = unsafe { C = 1; 0 };
-//~^ ERROR cannot mutate statics in the initializer of another static
+//~^ ERROR cycle detected
pub static D: u32 = D;
diff --git a/src/test/ui/write-to-static-mut-in-static.stderr b/src/test/ui/write-to-static-mut-in-static.stderr
index 673a71b..335f849 100644
--- a/src/test/ui/write-to-static-mut-in-static.stderr
+++ b/src/test/ui/write-to-static-mut-in-static.stderr
@@ -1,14 +1,28 @@
-error: cannot mutate statics in the initializer of another static
+error[E0080]: could not evaluate static initializer
--> $DIR/write-to-static-mut-in-static.rs:14:33
|
LL | pub static mut B: () = unsafe { A = 1; };
- | ^^^^^
+ | ^^^^^ tried to modify a static's initial value from another static's initializer
-error: cannot mutate statics in the initializer of another static
+error[E0391]: cycle detected when const-evaluating `C`
--> $DIR/write-to-static-mut-in-static.rs:17:34
|
LL | pub static mut C: u32 = unsafe { C = 1; 0 };
| ^^^^^
+ |
+note: ...which requires const-evaluating `C`...
+ --> $DIR/write-to-static-mut-in-static.rs:17:1
+ |
+LL | pub static mut C: u32 = unsafe { C = 1; 0 };
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ = note: ...which again requires const-evaluating `C`, completing the cycle
+note: cycle used when const-evaluating + checking `C`
+ --> $DIR/write-to-static-mut-in-static.rs:17:1
+ |
+LL | pub static mut C: u32 = unsafe { C = 1; 0 };
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to 2 previous errors
+Some errors occurred: E0080, E0391.
+For more information about an error, try `rustc --explain E0080`.
diff --git a/src/tools/cargo b/src/tools/cargo
index 1b6702f..8610973 160000
--- a/src/tools/cargo
+++ b/src/tools/cargo
@@ -1 +1 @@
-Subproject commit 1b6702f22a0dd54847684f29acd6617dd31a8479
+Subproject commit 8610973aaf48615ba7dc9a38a9a2795ba6f36a31
diff --git a/src/tools/rls b/src/tools/rls
index cfd8449..bfa1371 160000
--- a/src/tools/rls
+++ b/src/tools/rls
@@ -1 +1 @@
-Subproject commit cfd8449bd6fcfc6a0b53889c616faa4de4513636
+Subproject commit bfa1371f5cceacebe307d9ee70760296eb0ec489