Skip to content

Commit f69f52c

Browse files
canndrewnikomatsakis
canndrew
authored and
nikomatsakis
committed
remove defaulting to unit
Types will no longer default to `()`, instead always defaulting to `!`. This disables the associated warning and removes the flag from TyTuple
1 parent 932c736 commit f69f52c

Some content is hidden

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

58 files changed

+109
-244
lines changed

‎src/librustc/ich/impls_ty.rs

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -659,9 +659,8 @@ for ty::TypeVariants<'gcx>
659659
TyGeneratorWitness(types) => {
660660
types.hash_stable(hcx, hasher)
661661
}
662-
TyTuple(inner_tys, from_diverging_type_var) => {
662+
TyTuple(inner_tys) => {
663663
inner_tys.hash_stable(hcx, hasher);
664-
from_diverging_type_var.hash_stable(hcx, hasher);
665664
}
666665
TyProjection(ref projection_ty) => {
667666
projection_ty.hash_stable(hcx, hasher);

‎src/librustc/infer/resolve.rs

Lines changed: 0 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -173,12 +173,6 @@ impl<'a, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for FullTypeResolver<'a, 'gcx, 'tcx>
173173
ty::TyInfer(_) => {
174174
bug!("Unexpected type in full type resolver: {:?}", t);
175175
}
176-
ty::TyTuple(tys, true) => {
177-
// Un-default defaulted tuples - we are going to a
178-
// different infcx, and the default will just cause
179-
// pollution.
180-
self.tcx().intern_tup(tys, false)
181-
}
182176
_ => {
183177
t.super_fold_with(self)
184178
}

‎src/librustc/lint/builtin.rs

Lines changed: 0 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -142,13 +142,6 @@ declare_lint! {
142142
"lints that have been renamed or removed"
143143
}
144144

145-
declare_lint! {
146-
pub RESOLVE_TRAIT_ON_DEFAULTED_UNIT,
147-
Deny,
148-
"attempt to resolve a trait on an expression whose type cannot be inferred but which \
149-
currently defaults to ()"
150-
}
151-
152145
declare_lint! {
153146
pub SAFE_EXTERN_STATICS,
154147
Deny,
@@ -281,7 +274,6 @@ impl LintPass for HardwiredLints {
281274
INVALID_TYPE_PARAM_DEFAULT,
282275
CONST_ERR,
283276
RENAMED_AND_REMOVED_LINTS,
284-
RESOLVE_TRAIT_ON_DEFAULTED_UNIT,
285277
SAFE_EXTERN_STATICS,
286278
SAFE_PACKED_BORROWS,
287279
PATTERNS_IN_FNS_WITHOUT_BODY,

‎src/librustc/middle/mem_categorization.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1298,7 +1298,7 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
12981298
PatKind::Tuple(ref subpats, ddpos) => {
12991299
// (p1, ..., pN)
13001300
let expected_len = match self.pat_ty(&pat)?.sty {
1301-
ty::TyTuple(ref tys, _) => tys.len(),
1301+
ty::TyTuple(ref tys) => tys.len(),
13021302
ref ty => span_bug!(pat.span, "tuple pattern unexpected type {:?}", ty),
13031303
};
13041304
for (i, subpat) in subpats.iter().enumerate_and_adjust(expected_len, ddpos) {

‎src/librustc/mir/tcx.rs

Lines changed: 2 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -171,7 +171,7 @@ impl<'tcx> Rvalue<'tcx> {
171171
let lhs_ty = lhs.ty(local_decls, tcx);
172172
let rhs_ty = rhs.ty(local_decls, tcx);
173173
let ty = op.ty(tcx, lhs_ty, rhs_ty);
174-
tcx.intern_tup(&[ty, tcx.types.bool], false)
174+
tcx.intern_tup(&[ty, tcx.types.bool])
175175
}
176176
Rvalue::UnaryOp(UnOp::Not, ref operand) |
177177
Rvalue::UnaryOp(UnOp::Neg, ref operand) => {
@@ -195,10 +195,7 @@ impl<'tcx> Rvalue<'tcx> {
195195
tcx.mk_array(ty, ops.len() as u64)
196196
}
197197
AggregateKind::Tuple => {
198-
tcx.mk_tup(
199-
ops.iter().map(|op| op.ty(local_decls, tcx)),
200-
false
201-
)
198+
tcx.mk_tup(ops.iter().map(|op| op.ty(local_decls, tcx)))
202199
}
203200
AggregateKind::Adt(def, _, substs, _) => {
204201
tcx.type_of(def.did).subst(tcx, substs)

‎src/librustc/traits/error_reporting.rs

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -739,14 +739,14 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
739739
}).map(|sp| self.tcx.sess.codemap().def_span(sp)); // the sp could be an fn def
740740

741741
let found = match found_trait_ref.skip_binder().substs.type_at(1).sty {
742-
ty::TyTuple(ref tys, _) => tys.iter()
742+
ty::TyTuple(ref tys) => tys.iter()
743743
.map(|_| ArgKind::empty()).collect::<Vec<_>>(),
744744
_ => vec![ArgKind::empty()],
745745
};
746746
let expected = match expected_trait_ref.skip_binder().substs.type_at(1).sty {
747-
ty::TyTuple(ref tys, _) => tys.iter()
747+
ty::TyTuple(ref tys) => tys.iter()
748748
.map(|t| match t.sty {
749-
ty::TypeVariants::TyTuple(ref tys, _) => ArgKind::Tuple(
749+
ty::TypeVariants::TyTuple(ref tys) => ArgKind::Tuple(
750750
span,
751751
tys.iter()
752752
.map(|ty| ("_".to_owned(), format!("{}", ty.sty)))
@@ -971,7 +971,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
971971
fn build_fn_sig_string<'a, 'gcx, 'tcx>(tcx: ty::TyCtxt<'a, 'gcx, 'tcx>,
972972
trait_ref: &ty::TraitRef<'tcx>) -> String {
973973
let inputs = trait_ref.substs.type_at(1);
974-
let sig = if let ty::TyTuple(inputs, _) = inputs.sty {
974+
let sig = if let ty::TyTuple(inputs) = inputs.sty {
975975
tcx.mk_fn_sig(
976976
inputs.iter().map(|&x| x),
977977
tcx.mk_infer(ty::TyVar(ty::TyVid { index: 0 })),

‎src/librustc/traits/fulfill.rs

Lines changed: 1 addition & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -328,11 +328,7 @@ fn process_predicate<'a, 'gcx, 'tcx>(
328328
if data.is_global() {
329329
// no type variables present, can use evaluation for better caching.
330330
// FIXME: consider caching errors too.
331-
if
332-
// make defaulted unit go through the slow path for better warnings,
333-
// please remove this when the warnings are removed.
334-
!trait_obligation.predicate.skip_binder().self_ty().is_defaulted_unit() &&
335-
selcx.evaluate_obligation_conservatively(&obligation) {
331+
if selcx.evaluate_obligation_conservatively(&obligation) {
336332
debug!("selecting trait `{:?}` at depth {} evaluated to holds",
337333
data, obligation.recursion_depth);
338334
return Ok(Some(vec![]))

‎src/librustc/traits/select.rs

Lines changed: 6 additions & 49 deletions
Original file line numberDiff line numberDiff line change
@@ -52,7 +52,6 @@ use std::mem;
5252
use std::rc::Rc;
5353
use syntax::abi::Abi;
5454
use hir;
55-
use lint;
5655
use util::nodemap::FxHashMap;
5756

5857
struct InferredObligationsSnapshotVecDelegate<'tcx> {
@@ -533,8 +532,6 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
533532
debug!("select({:?})", obligation);
534533
assert!(!obligation.predicate.has_escaping_regions());
535534

536-
let tcx = self.tcx();
537-
538535
let stack = self.push_stack(TraitObligationStackList::empty(), obligation);
539536
let ret = match self.candidate_from_obligation(&stack)? {
540537
None => None,
@@ -546,46 +543,6 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
546543
},
547544
};
548545

549-
// Test whether this is a `()` which was produced by defaulting a
550-
// diverging type variable with `!` disabled. If so, we may need
551-
// to raise a warning.
552-
if obligation.predicate.skip_binder().self_ty().is_defaulted_unit() {
553-
let mut raise_warning = true;
554-
// Don't raise a warning if the trait is implemented for ! and only
555-
// permits a trivial implementation for !. This stops us warning
556-
// about (for example) `(): Clone` becoming `!: Clone` because such
557-
// a switch can't cause code to stop compiling or execute
558-
// differently.
559-
let mut never_obligation = obligation.clone();
560-
let def_id = never_obligation.predicate.skip_binder().trait_ref.def_id;
561-
never_obligation.predicate = never_obligation.predicate.map_bound(|mut trait_pred| {
562-
// Swap out () with ! so we can check if the trait is impld for !
563-
{
564-
let trait_ref = &mut trait_pred.trait_ref;
565-
let unit_substs = trait_ref.substs;
566-
let mut never_substs = Vec::with_capacity(unit_substs.len());
567-
never_substs.push(From::from(tcx.types.never));
568-
never_substs.extend(&unit_substs[1..]);
569-
trait_ref.substs = tcx.intern_substs(&never_substs);
570-
}
571-
trait_pred
572-
});
573-
if let Ok(Some(..)) = self.select(&never_obligation) {
574-
if !tcx.trait_relevant_for_never(def_id) {
575-
// The trait is also implemented for ! and the resulting
576-
// implementation cannot actually be invoked in any way.
577-
raise_warning = false;
578-
}
579-
}
580-
581-
if raise_warning {
582-
tcx.lint_node(lint::builtin::RESOLVE_TRAIT_ON_DEFAULTED_UNIT,
583-
obligation.cause.body_id,
584-
obligation.cause.span,
585-
&format!("code relies on type inference rules which are likely \
586-
to change"));
587-
}
588-
}
589546
Ok(ret)
590547
}
591548

@@ -1937,7 +1894,7 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
19371894
}
19381895

19391896
// (.., T) -> (.., U).
1940-
(&ty::TyTuple(tys_a, _), &ty::TyTuple(tys_b, _)) => {
1897+
(&ty::TyTuple(tys_a), &ty::TyTuple(tys_b)) => {
19411898
tys_a.len() == tys_b.len()
19421899
}
19431900

@@ -2076,7 +2033,7 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
20762033

20772034
ty::TyStr | ty::TySlice(_) | ty::TyDynamic(..) | ty::TyForeign(..) => Never,
20782035

2079-
ty::TyTuple(tys, _) => {
2036+
ty::TyTuple(tys) => {
20802037
Where(ty::Binder(tys.last().into_iter().cloned().collect()))
20812038
}
20822039

@@ -2129,7 +2086,7 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
21292086
Where(ty::Binder(vec![element_ty]))
21302087
}
21312088

2132-
ty::TyTuple(tys, _) => {
2089+
ty::TyTuple(tys) => {
21332090
// (*) binder moved here
21342091
Where(ty::Binder(tys.to_vec()))
21352092
}
@@ -2220,7 +2177,7 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
22202177
vec![element_ty]
22212178
}
22222179

2223-
ty::TyTuple(ref tys, _) => {
2180+
ty::TyTuple(ref tys) => {
22242181
// (T1, ..., Tn) -- meets any bound that all of T1...Tn meet
22252182
tys.to_vec()
22262183
}
@@ -2999,7 +2956,7 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
29992956
}
30002957

30012958
// (.., T) -> (.., U).
3002-
(&ty::TyTuple(tys_a, _), &ty::TyTuple(tys_b, _)) => {
2959+
(&ty::TyTuple(tys_a), &ty::TyTuple(tys_b)) => {
30032960
assert_eq!(tys_a.len(), tys_b.len());
30042961

30052962
// The last field of the tuple has to exist.
@@ -3012,7 +2969,7 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
30122969

30132970
// Check that the source tuple with the target's
30142971
// last element is equal to the target.
3015-
let new_tuple = tcx.mk_tup(a_mid.iter().chain(Some(b_last)), false);
2972+
let new_tuple = tcx.mk_tup(a_mid.iter().chain(Some(b_last)));
30162973
let InferOk { obligations, .. } =
30172974
self.infcx.at(&obligation.cause, obligation.param_env)
30182975
.eq(target, new_tuple)

‎src/librustc/traits/util.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -511,7 +511,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
511511
let arguments_tuple = match tuple_arguments {
512512
TupleArgumentsFlag::No => sig.skip_binder().inputs()[0],
513513
TupleArgumentsFlag::Yes =>
514-
self.intern_tup(sig.skip_binder().inputs(), false),
514+
self.intern_tup(sig.skip_binder().inputs()),
515515
};
516516
let trait_ref = ty::TraitRef {
517517
def_id: fn_trait_def_id,

‎src/librustc/ty/context.rs

Lines changed: 6 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -1881,7 +1881,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
18811881
pub fn coerce_closure_fn_ty(self, sig: PolyFnSig<'tcx>) -> Ty<'tcx> {
18821882
let converted_sig = sig.map_bound(|s| {
18831883
let params_iter = match s.inputs()[0].sty {
1884-
ty::TyTuple(params, _) => {
1884+
ty::TyTuple(params) => {
18851885
params.into_iter().cloned()
18861886
}
18871887
_ => bug!(),
@@ -2006,25 +2006,16 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
20062006
self.mk_ty(TySlice(ty))
20072007
}
20082008

2009-
pub fn intern_tup(self, ts: &[Ty<'tcx>], defaulted: bool) -> Ty<'tcx> {
2010-
self.mk_ty(TyTuple(self.intern_type_list(ts), defaulted))
2009+
pub fn intern_tup(self, ts: &[Ty<'tcx>]) -> Ty<'tcx> {
2010+
self.mk_ty(TyTuple(self.intern_type_list(ts)))
20112011
}
20122012

2013-
pub fn mk_tup<I: InternAs<[Ty<'tcx>], Ty<'tcx>>>(self, iter: I,
2014-
defaulted: bool) -> I::Output {
2015-
iter.intern_with(|ts| self.mk_ty(TyTuple(self.intern_type_list(ts), defaulted)))
2013+
pub fn mk_tup<I: InternAs<[Ty<'tcx>], Ty<'tcx>>>(self, iter: I) -> I::Output {
2014+
iter.intern_with(|ts| self.mk_ty(TyTuple(self.intern_type_list(ts))))
20162015
}
20172016

20182017
pub fn mk_nil(self) -> Ty<'tcx> {
2019-
self.intern_tup(&[], false)
2020-
}
2021-
2022-
pub fn mk_diverging_default(self) -> Ty<'tcx> {
2023-
if self.sess.features.borrow().never_type {
2024-
self.types.never
2025-
} else {
2026-
self.intern_tup(&[], true)
2027-
}
2018+
self.intern_tup(&[])
20282019
}
20292020

20302021
pub fn mk_bool(self) -> Ty<'tcx> {

0 commit comments

Comments
 (0)