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

+1-2
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

-6
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

-8
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

+1-1
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

+2-5
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

+4-4
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

+1-5
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

+6-49
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

+1-1
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

+6-15
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> {

‎src/librustc/ty/error.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -188,7 +188,7 @@ impl<'a, 'gcx, 'lcx, 'tcx> ty::TyS<'tcx> {
188188
match self.sty {
189189
ty::TyBool | ty::TyChar | ty::TyInt(_) |
190190
ty::TyUint(_) | ty::TyFloat(_) | ty::TyStr | ty::TyNever => self.to_string(),
191-
ty::TyTuple(ref tys, _) if tys.is_empty() => self.to_string(),
191+
ty::TyTuple(ref tys) if tys.is_empty() => self.to_string(),
192192

193193
ty::TyAdt(def, _) => format!("{} `{}`", def.descr(), tcx.item_path_str(def.did)),
194194
ty::TyForeign(def_id) => format!("extern type `{}`", tcx.item_path_str(def_id)),

‎src/librustc/ty/fast_reject.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -97,7 +97,7 @@ pub fn simplify_type<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>,
9797
Some(GeneratorWitnessSimplifiedType(tys.skip_binder().len()))
9898
}
9999
ty::TyNever => Some(NeverSimplifiedType),
100-
ty::TyTuple(ref tys, _) => {
100+
ty::TyTuple(ref tys) => {
101101
Some(TupleSimplifiedType(tys.len()))
102102
}
103103
ty::TyFnPtr(ref f) => {

‎src/librustc/ty/flags.rs

+1-4
Original file line numberDiff line numberDiff line change
@@ -171,10 +171,7 @@ impl FlagComputation {
171171
self.add_ty(m.ty);
172172
}
173173

174-
&ty::TyTuple(ref ts, is_default) => {
175-
if is_default {
176-
self.add_flags(TypeFlags::KEEP_IN_LOCAL_TCX);
177-
}
174+
&ty::TyTuple(ref ts) => {
178175
self.add_tys(&ts[..]);
179176
}
180177

‎src/librustc/ty/inhabitedness/mod.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -256,7 +256,7 @@ impl<'a, 'gcx, 'tcx> TyS<'tcx> {
256256
},
257257

258258
TyNever => DefIdForest::full(tcx),
259-
TyTuple(ref tys, _) => {
259+
TyTuple(ref tys) => {
260260
DefIdForest::union(tcx, tys.iter().map(|ty| {
261261
ty.uninhabited_from(visited, tcx)
262262
}))

‎src/librustc/ty/item_path.rs

+3-3
Original file line numberDiff line numberDiff line change
@@ -355,9 +355,9 @@ pub fn characteristic_def_id_of_type(ty: Ty) -> Option<DefId> {
355355
ty::TyRawPtr(mt) |
356356
ty::TyRef(_, mt) => characteristic_def_id_of_type(mt.ty),
357357

358-
ty::TyTuple(ref tys, _) => tys.iter()
359-
.filter_map(|ty| characteristic_def_id_of_type(ty))
360-
.next(),
358+
ty::TyTuple(ref tys) => tys.iter()
359+
.filter_map(|ty| characteristic_def_id_of_type(ty))
360+
.next(),
361361

362362
ty::TyFnDef(def_id, _) |
363363
ty::TyClosure(def_id, _) |

‎src/librustc/ty/layout.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -1307,7 +1307,7 @@ impl<'a, 'tcx> LayoutCx<'tcx, TyCtxt<'a, 'tcx, 'tcx>> {
13071307
StructKind::AlwaysSized)?
13081308
}
13091309

1310-
ty::TyTuple(tys, _) => {
1310+
ty::TyTuple(tys) => {
13111311
let kind = if tys.len() == 0 {
13121312
StructKind::AlwaysSized
13131313
} else {
@@ -2232,7 +2232,7 @@ impl<'a, 'tcx> TyLayout<'tcx> {
22322232
substs.field_tys(def_id, tcx).nth(i).unwrap()
22332233
}
22342234

2235-
ty::TyTuple(tys, _) => tys[i],
2235+
ty::TyTuple(tys) => tys[i],
22362236

22372237
// SIMD vector types.
22382238
ty::TyAdt(def, ..) if def.repr.simd() => {

‎src/librustc/ty/mod.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -1915,7 +1915,7 @@ impl<'a, 'gcx, 'tcx> AdtDef {
19151915
vec![ty]
19161916
}
19171917

1918-
TyTuple(ref tys, _) => {
1918+
TyTuple(ref tys) => {
19191919
match tys.last() {
19201920
None => vec![],
19211921
Some(ty) => self.sized_constraint_for_ty(tcx, ty)

‎src/librustc/ty/relate.rs

+2-3
Original file line numberDiff line numberDiff line change
@@ -524,11 +524,10 @@ pub fn super_relate_tys<'a, 'gcx, 'tcx, R>(relation: &mut R,
524524
Ok(tcx.mk_slice(t))
525525
}
526526

527-
(&ty::TyTuple(as_, a_defaulted), &ty::TyTuple(bs, b_defaulted)) =>
527+
(&ty::TyTuple(as_), &ty::TyTuple(bs)) =>
528528
{
529529
if as_.len() == bs.len() {
530-
let defaulted = a_defaulted || b_defaulted;
531-
Ok(tcx.mk_tup(as_.iter().zip(bs).map(|(a, b)| relation.relate(a, b)), defaulted)?)
530+
Ok(tcx.mk_tup(as_.iter().zip(bs).map(|(a, b)| relation.relate(a, b)))?)
532531
} else if !(as_.is_empty() || bs.is_empty()) {
533532
Err(TypeError::TupleSize(
534533
expected_found(relation, &as_.len(), &bs.len())))

‎src/librustc/ty/structural_impls.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -787,7 +787,7 @@ impl<'tcx> TypeFoldable<'tcx> for Ty<'tcx> {
787787
ty::TyAdt(tid, substs) => ty::TyAdt(tid, substs.fold_with(folder)),
788788
ty::TyDynamic(ref trait_ty, ref region) =>
789789
ty::TyDynamic(trait_ty.fold_with(folder), region.fold_with(folder)),
790-
ty::TyTuple(ts, defaulted) => ty::TyTuple(ts.fold_with(folder), defaulted),
790+
ty::TyTuple(ts) => ty::TyTuple(ts.fold_with(folder)),
791791
ty::TyFnDef(def_id, substs) => {
792792
ty::TyFnDef(def_id, substs.fold_with(folder))
793793
}
@@ -826,7 +826,7 @@ impl<'tcx> TypeFoldable<'tcx> for Ty<'tcx> {
826826
ty::TyAdt(_, substs) => substs.visit_with(visitor),
827827
ty::TyDynamic(ref trait_ty, ref reg) =>
828828
trait_ty.visit_with(visitor) || reg.visit_with(visitor),
829-
ty::TyTuple(ts, _) => ts.visit_with(visitor),
829+
ty::TyTuple(ts) => ts.visit_with(visitor),
830830
ty::TyFnDef(_, substs) => substs.visit_with(visitor),
831831
ty::TyFnPtr(ref f) => f.visit_with(visitor),
832832
ty::TyRef(r, ref tm) => r.visit_with(visitor) || tm.visit_with(visitor),

0 commit comments

Comments
 (0)