Skip to content

Commit 37b1fa8

Browse files
oli-obkoli-obk
committed
Add or-patterns to pattern types
1 parent 4a8b13e commit 37b1fa8

File tree

34 files changed

+493
-9
lines changed

34 files changed

+493
-9
lines changed

‎compiler/rustc_ast/src/ast.rs

+2
Original file line numberDiff line numberDiff line change
@@ -2481,6 +2481,8 @@ pub enum TyPatKind {
24812481
/// A range pattern (e.g., `1...2`, `1..2`, `1..`, `..2`, `1..=2`, `..=2`).
24822482
Range(Option<P<AnonConst>>, Option<P<AnonConst>>, Spanned<RangeEnd>),
24832483

2484+
Or(ThinVec<P<TyPat>>),
2485+
24842486
/// Placeholder for a pattern that wasn't syntactically well formed in some way.
24852487
Err(ErrorGuaranteed),
24862488
}

‎compiler/rustc_ast/src/mut_visit.rs

+1
Original file line numberDiff line numberDiff line change
@@ -612,6 +612,7 @@ pub fn walk_ty_pat<T: MutVisitor>(vis: &mut T, ty: &mut P<TyPat>) {
612612
visit_opt(start, |c| vis.visit_anon_const(c));
613613
visit_opt(end, |c| vis.visit_anon_const(c));
614614
}
615+
TyPatKind::Or(variants) => visit_thin_vec(variants, |p| vis.visit_ty_pat(p)),
615616
TyPatKind::Err(_) => {}
616617
}
617618
visit_lazy_tts(vis, tokens);

‎compiler/rustc_ast/src/visit.rs

+1
Original file line numberDiff line numberDiff line change
@@ -608,6 +608,7 @@ pub fn walk_ty_pat<'a, V: Visitor<'a>>(visitor: &mut V, tp: &'a TyPat) -> V::Res
608608
visit_opt!(visitor, visit_anon_const, start);
609609
visit_opt!(visitor, visit_anon_const, end);
610610
}
611+
TyPatKind::Or(variants) => walk_list!(visitor, visit_ty_pat, variants),
611612
TyPatKind::Err(_) => {}
612613
}
613614
V::Result::output()

‎compiler/rustc_ast_lowering/src/pat.rs

+5
Original file line numberDiff line numberDiff line change
@@ -464,6 +464,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
464464
)
465465
}),
466466
),
467+
TyPatKind::Or(variants) => {
468+
hir::TyPatKind::Or(self.arena.alloc_from_iter(
469+
variants.iter().map(|pat| self.lower_ty_pat_mut(pat, base_type)),
470+
))
471+
}
467472
TyPatKind::Err(guar) => hir::TyPatKind::Err(*guar),
468473
};
469474

‎compiler/rustc_ast_pretty/src/pprust/state.rs

+11
Original file line numberDiff line numberDiff line change
@@ -1163,6 +1163,17 @@ impl<'a> State<'a> {
11631163
self.print_expr_anon_const(end, &[]);
11641164
}
11651165
}
1166+
rustc_ast::TyPatKind::Or(variants) => {
1167+
let mut first = true;
1168+
for pat in variants {
1169+
if first {
1170+
first = false
1171+
} else {
1172+
self.word(" | ");
1173+
}
1174+
self.print_ty_pat(pat);
1175+
}
1176+
}
11661177
rustc_ast::TyPatKind::Err(_) => {
11671178
self.popen();
11681179
self.word("/*ERROR*/");

‎compiler/rustc_builtin_macros/src/pattern_type.rs

+15-1
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,7 @@ use rustc_ast::{AnonConst, DUMMY_NODE_ID, Ty, TyPat, TyPatKind, ast, token};
44
use rustc_errors::PResult;
55
use rustc_expand::base::{self, DummyResult, ExpandResult, ExtCtxt, MacroExpanderResult};
66
use rustc_parse::exp;
7+
use rustc_parse::parser::{CommaRecoveryMode, RecoverColon, RecoverComma};
78
use rustc_span::Span;
89

910
pub(crate) fn expand<'cx>(
@@ -27,7 +28,17 @@ fn parse_pat_ty<'a>(cx: &mut ExtCtxt<'a>, stream: TokenStream) -> PResult<'a, (P
2728
let ty = parser.parse_ty()?;
2829
parser.expect_keyword(exp!(Is))?;
2930

30-
let pat = pat_to_ty_pat(cx, parser.parse_pat_no_top_alt(None, None)?.into_inner());
31+
let pat = pat_to_ty_pat(
32+
cx,
33+
parser
34+
.parse_pat_no_top_guard(
35+
None,
36+
RecoverComma::No,
37+
RecoverColon::No,
38+
CommaRecoveryMode::EitherTupleOrPipe,
39+
)?
40+
.into_inner(),
41+
);
3142

3243
if parser.token != token::Eof {
3344
parser.unexpected()?;
@@ -47,6 +58,9 @@ fn pat_to_ty_pat(cx: &mut ExtCtxt<'_>, pat: ast::Pat) -> P<TyPat> {
4758
end.map(|value| P(AnonConst { id: DUMMY_NODE_ID, value })),
4859
include_end,
4960
),
61+
ast::PatKind::Or(variants) => TyPatKind::Or(
62+
variants.into_iter().map(|pat| pat_to_ty_pat(cx, pat.into_inner())).collect(),
63+
),
5064
ast::PatKind::Err(guar) => TyPatKind::Err(guar),
5165
_ => TyPatKind::Err(cx.dcx().span_err(pat.span, "pattern not supported in pattern types")),
5266
};

‎compiler/rustc_const_eval/src/interpret/intrinsics.rs

+3
Original file line numberDiff line numberDiff line change
@@ -70,6 +70,9 @@ pub(crate) fn eval_nullary_intrinsic<'tcx>(
7070
ty::Pat(_, pat) => match **pat {
7171
ty::PatternKind::Range { .. } => ConstValue::from_target_usize(0u64, &tcx),
7272
// Future pattern kinds may have more variants
73+
// FIXME(pattern_types): make this report the number of distinct variants used in the
74+
// or pattern in case the base type is an enum.
75+
ty::PatternKind::Or(_) => ConstValue::from_target_usize(0_u64, &tcx),
7376
},
7477
ty::Bound(_, _) => bug!("bound ty during ctfe"),
7578
ty::Bool

‎compiler/rustc_const_eval/src/interpret/validity.rs

+4
Original file line numberDiff line numberDiff line change
@@ -1248,6 +1248,10 @@ impl<'rt, 'tcx, M: Machine<'tcx>> ValueVisitor<'tcx, M> for ValidityVisitor<'rt,
12481248
// Range patterns are precisely reflected into `valid_range` and thus
12491249
// handled fully by `visit_scalar` (called below).
12501250
ty::PatternKind::Range { .. } => {},
1251+
1252+
// FIXME(pattern_types): check that the value is covered by one of the variants.
1253+
// The layout may pessimistically cover actually illegal ranges.
1254+
ty::PatternKind::Or(_patterns) => {}
12511255
}
12521256
}
12531257
_ => {

‎compiler/rustc_hir/src/hir.rs

+3
Original file line numberDiff line numberDiff line change
@@ -1715,6 +1715,9 @@ pub enum TyPatKind<'hir> {
17151715
/// A range pattern (e.g., `1..=2` or `1..2`).
17161716
Range(&'hir ConstArg<'hir>, &'hir ConstArg<'hir>),
17171717

1718+
/// A list of patterns where only one needs to be satisfied
1719+
Or(&'hir [TyPat<'hir>]),
1720+
17181721
/// A placeholder for a pattern that wasn't well formed in some way.
17191722
Err(ErrorGuaranteed),
17201723
}

‎compiler/rustc_hir/src/intravisit.rs

+1
Original file line numberDiff line numberDiff line change
@@ -710,6 +710,7 @@ pub fn walk_ty_pat<'v, V: Visitor<'v>>(visitor: &mut V, pattern: &'v TyPat<'v>)
710710
try_visit!(visitor.visit_const_arg_unambig(lower_bound));
711711
try_visit!(visitor.visit_const_arg_unambig(upper_bound));
712712
}
713+
TyPatKind::Or(patterns) => walk_list!(visitor, visit_pattern_type_pattern, patterns),
713714
TyPatKind::Err(_) => (),
714715
}
715716
V::Result::output()

‎compiler/rustc_hir_analysis/src/collect/type_of.rs

+5-3
Original file line numberDiff line numberDiff line change
@@ -94,10 +94,12 @@ fn const_arg_anon_type_of<'tcx>(icx: &ItemCtxt<'tcx>, arg_hir_id: HirId, span: S
9494
}
9595

9696
Node::TyPat(pat) => {
97-
let hir::TyKind::Pat(ty, p) = tcx.parent_hir_node(pat.hir_id).expect_ty().kind else {
98-
bug!()
97+
let node = match tcx.parent_hir_node(pat.hir_id) {
98+
// Or patterns can be nested one level deep
99+
Node::TyPat(p) => tcx.parent_hir_node(p.hir_id),
100+
other => other,
99101
};
100-
assert_eq!(p.hir_id, pat.hir_id);
102+
let hir::TyKind::Pat(ty, _) = node.expect_ty().kind else { bug!() };
101103
icx.lower_ty(ty)
102104
}
103105

‎compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

+8
Original file line numberDiff line numberDiff line change
@@ -2735,6 +2735,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
27352735
ty_span: Span,
27362736
pat: &hir::TyPat<'tcx>,
27372737
) -> Result<ty::PatternKind<'tcx>, ErrorGuaranteed> {
2738+
let tcx = self.tcx();
27382739
match pat.kind {
27392740
hir::TyPatKind::Range(start, end) => {
27402741
match ty.kind() {
@@ -2750,6 +2751,13 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
27502751
.span_delayed_bug(ty_span, "invalid base type for range pattern")),
27512752
}
27522753
}
2754+
hir::TyPatKind::Or(patterns) => {
2755+
self.tcx()
2756+
.mk_patterns_from_iter(patterns.iter().map(|pat| {
2757+
self.lower_pat_ty_pat(ty, ty_span, pat).map(|pat| tcx.mk_pat(pat))
2758+
}))
2759+
.map(ty::PatternKind::Or)
2760+
}
27532761
hir::TyPatKind::Err(e) => Err(e),
27542762
}
27552763
}

‎compiler/rustc_hir_analysis/src/variance/constraints.rs

+5
Original file line numberDiff line numberDiff line change
@@ -340,6 +340,11 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
340340
self.add_constraints_from_const(current, start, variance);
341341
self.add_constraints_from_const(current, end, variance);
342342
}
343+
ty::PatternKind::Or(patterns) => {
344+
for pat in patterns {
345+
self.add_constraints_from_pat(current, variance, pat)
346+
}
347+
}
343348
}
344349
}
345350

‎compiler/rustc_hir_pretty/src/lib.rs

+13
Original file line numberDiff line numberDiff line change
@@ -1859,6 +1859,19 @@ impl<'a> State<'a> {
18591859
self.word("..=");
18601860
self.print_const_arg(end);
18611861
}
1862+
TyPatKind::Or(patterns) => {
1863+
self.popen();
1864+
let mut first = true;
1865+
for pat in patterns {
1866+
if first {
1867+
first = false;
1868+
} else {
1869+
self.word(" | ");
1870+
}
1871+
self.print_ty_pat(pat);
1872+
}
1873+
self.pclose();
1874+
}
18621875
TyPatKind::Err(_) => {
18631876
self.popen();
18641877
self.word("/*ERROR*/");

‎compiler/rustc_lint/src/types.rs

+22-3
Original file line numberDiff line numberDiff line change
@@ -898,6 +898,9 @@ fn pat_ty_is_known_nonnull<'tcx>(
898898
// to ensure we aren't wrapping over zero.
899899
start > 0 && end >= start
900900
}
901+
ty::PatternKind::Or(patterns) => {
902+
patterns.iter().all(|pat| pat_ty_is_known_nonnull(tcx, typing_env, pat))
903+
}
901904
}
902905
},
903906
)
@@ -1044,13 +1047,29 @@ pub(crate) fn repr_nullable_ptr<'tcx>(
10441047
}
10451048
None
10461049
}
1047-
ty::Pat(base, pat) => match **pat {
1048-
ty::PatternKind::Range { .. } => get_nullable_type(tcx, typing_env, *base),
1049-
},
1050+
ty::Pat(base, pat) => get_nullable_type_from_pat(tcx, typing_env, *base, *pat),
10501051
_ => None,
10511052
}
10521053
}
10531054

1055+
fn get_nullable_type_from_pat<'tcx>(
1056+
tcx: TyCtxt<'tcx>,
1057+
typing_env: ty::TypingEnv<'tcx>,
1058+
base: Ty<'tcx>,
1059+
pat: ty::Pattern<'tcx>,
1060+
) -> Option<Ty<'tcx>> {
1061+
match *pat {
1062+
ty::PatternKind::Range { .. } => get_nullable_type(tcx, typing_env, base),
1063+
ty::PatternKind::Or(patterns) => {
1064+
let first = get_nullable_type_from_pat(tcx, typing_env, base, patterns[0])?;
1065+
for &pat in &patterns[1..] {
1066+
assert_eq!(first, get_nullable_type_from_pat(tcx, typing_env, base, pat)?);
1067+
}
1068+
Some(first)
1069+
}
1070+
}
1071+
}
1072+
10541073
impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
10551074
/// Check if the type is array and emit an unsafe type lint.
10561075
fn check_for_array_ty(&mut self, sp: Span, ty: Ty<'tcx>) -> bool {

‎compiler/rustc_middle/src/ty/codec.rs

+10
Original file line numberDiff line numberDiff line change
@@ -442,6 +442,15 @@ impl<'tcx, D: TyDecoder<'tcx>> RefDecodable<'tcx, D> for ty::List<ty::BoundVaria
442442
}
443443
}
444444

445+
impl<'tcx, D: TyDecoder<'tcx>> RefDecodable<'tcx, D> for ty::List<ty::Pattern<'tcx>> {
446+
fn decode(decoder: &mut D) -> &'tcx Self {
447+
let len = decoder.read_usize();
448+
decoder.interner().mk_patterns_from_iter(
449+
(0..len).map::<ty::Pattern<'tcx>, _>(|_| Decodable::decode(decoder)),
450+
)
451+
}
452+
}
453+
445454
impl<'tcx, D: TyDecoder<'tcx>> RefDecodable<'tcx, D> for ty::List<ty::Const<'tcx>> {
446455
fn decode(decoder: &mut D) -> &'tcx Self {
447456
let len = decoder.read_usize();
@@ -503,6 +512,7 @@ impl_decodable_via_ref! {
503512
&'tcx mir::Body<'tcx>,
504513
&'tcx mir::ConcreteOpaqueTypes<'tcx>,
505514
&'tcx ty::List<ty::BoundVariableKind>,
515+
&'tcx ty::List<ty::Pattern<'tcx>>,
506516
&'tcx ty::ListWithCachedTypeInfo<ty::Clause<'tcx>>,
507517
&'tcx ty::List<FieldIdx>,
508518
&'tcx ty::List<(VariantIdx, FieldIdx)>,

‎compiler/rustc_middle/src/ty/context.rs

+12
Original file line numberDiff line numberDiff line change
@@ -136,6 +136,7 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
136136

137137
type AllocId = crate::mir::interpret::AllocId;
138138
type Pat = Pattern<'tcx>;
139+
type PatList = &'tcx List<Pattern<'tcx>>;
139140
type Safety = hir::Safety;
140141
type Abi = ExternAbi;
141142
type Const = ty::Const<'tcx>;
@@ -824,6 +825,7 @@ pub struct CtxtInterners<'tcx> {
824825
captures: InternedSet<'tcx, List<&'tcx ty::CapturedPlace<'tcx>>>,
825826
offset_of: InternedSet<'tcx, List<(VariantIdx, FieldIdx)>>,
826827
valtree: InternedSet<'tcx, ty::ValTreeKind<'tcx>>,
828+
patterns: InternedSet<'tcx, List<ty::Pattern<'tcx>>>,
827829
}
828830

829831
impl<'tcx> CtxtInterners<'tcx> {
@@ -860,6 +862,7 @@ impl<'tcx> CtxtInterners<'tcx> {
860862
captures: InternedSet::with_capacity(N),
861863
offset_of: InternedSet::with_capacity(N),
862864
valtree: InternedSet::with_capacity(N),
865+
patterns: InternedSet::with_capacity(N),
863866
}
864867
}
865868

@@ -2640,6 +2643,7 @@ slice_interners!(
26402643
local_def_ids: intern_local_def_ids(LocalDefId),
26412644
captures: intern_captures(&'tcx ty::CapturedPlace<'tcx>),
26422645
offset_of: pub mk_offset_of((VariantIdx, FieldIdx)),
2646+
patterns: pub mk_patterns(Pattern<'tcx>),
26432647
);
26442648

26452649
impl<'tcx> TyCtxt<'tcx> {
@@ -2913,6 +2917,14 @@ impl<'tcx> TyCtxt<'tcx> {
29132917
self.intern_local_def_ids(clauses)
29142918
}
29152919

2920+
pub fn mk_patterns_from_iter<I, T>(self, iter: I) -> T::Output
2921+
where
2922+
I: Iterator<Item = T>,
2923+
T: CollectAndApply<ty::Pattern<'tcx>, &'tcx List<ty::Pattern<'tcx>>>,
2924+
{
2925+
T::collect_and_apply(iter, |xs| self.mk_patterns(xs))
2926+
}
2927+
29162928
pub fn mk_local_def_ids_from_iter<I, T>(self, iter: I) -> T::Output
29172929
where
29182930
I: Iterator<Item = T>,

‎compiler/rustc_middle/src/ty/pattern.rs

+27
Original file line numberDiff line numberDiff line change
@@ -23,6 +23,13 @@ impl<'tcx> Flags for Pattern<'tcx> {
2323
FlagComputation::for_const_kind(&start.kind()).flags
2424
| FlagComputation::for_const_kind(&end.kind()).flags
2525
}
26+
ty::PatternKind::Or(pats) => {
27+
let mut flags = pats[0].flags();
28+
for pat in pats[1..].iter() {
29+
flags |= pat.flags();
30+
}
31+
flags
32+
}
2633
}
2734
}
2835

@@ -31,6 +38,13 @@ impl<'tcx> Flags for Pattern<'tcx> {
3138
ty::PatternKind::Range { start, end } => {
3239
start.outer_exclusive_binder().max(end.outer_exclusive_binder())
3340
}
41+
ty::PatternKind::Or(pats) => {
42+
let mut idx = pats[0].outer_exclusive_binder();
43+
for pat in pats[1..].iter() {
44+
idx = idx.max(pat.outer_exclusive_binder());
45+
}
46+
idx
47+
}
3448
}
3549
}
3650
}
@@ -77,6 +91,19 @@ impl<'tcx> IrPrint<PatternKind<'tcx>> for TyCtxt<'tcx> {
7791

7892
write!(f, "..={end}")
7993
}
94+
PatternKind::Or(patterns) => {
95+
write!(f, "(")?;
96+
let mut first = true;
97+
for pat in patterns {
98+
if first {
99+
first = false
100+
} else {
101+
write!(f, " | ")?;
102+
}
103+
write!(f, "{pat:?}")?;
104+
}
105+
write!(f, ")")
106+
}
80107
}
81108
}
82109

‎compiler/rustc_middle/src/ty/relate.rs

+9
Original file line numberDiff line numberDiff line change
@@ -59,6 +59,15 @@ impl<'tcx> Relate<TyCtxt<'tcx>> for ty::Pattern<'tcx> {
5959
let end = relation.relate(end_a, end_b)?;
6060
Ok(tcx.mk_pat(ty::PatternKind::Range { start, end }))
6161
}
62+
(&ty::PatternKind::Or(a), &ty::PatternKind::Or(b)) => {
63+
if a.len() != b.len() {
64+
return Err(TypeError::Mismatch);
65+
}
66+
let v = iter::zip(a, b).map(|(a, b)| relation.relate(a, b));
67+
let patterns = tcx.mk_patterns_from_iter(v)?;
68+
Ok(tcx.mk_pat(ty::PatternKind::Or(patterns)))
69+
}
70+
(ty::PatternKind::Range { .. } | ty::PatternKind::Or(_), _) => Err(TypeError::Mismatch),
6271
}
6372
}
6473
}

‎compiler/rustc_middle/src/ty/structural_impls.rs

+1
Original file line numberDiff line numberDiff line change
@@ -773,5 +773,6 @@ list_fold! {
773773
ty::Clauses<'tcx> : mk_clauses,
774774
&'tcx ty::List<ty::PolyExistentialPredicate<'tcx>> : mk_poly_existential_predicates,
775775
&'tcx ty::List<PlaceElem<'tcx>> : mk_place_elems,
776+
&'tcx ty::List<ty::Pattern<'tcx>> : mk_patterns,
776777
CanonicalVarInfos<'tcx> : mk_canonical_var_infos,
777778
}

‎compiler/rustc_resolve/src/late.rs

+5
Original file line numberDiff line numberDiff line change
@@ -958,6 +958,11 @@ impl<'ra: 'ast, 'ast, 'tcx> Visitor<'ast> for LateResolutionVisitor<'_, 'ast, 'r
958958
self.resolve_anon_const(end, AnonConstKind::ConstArg(IsRepeatExpr::No));
959959
}
960960
}
961+
TyPatKind::Or(patterns) => {
962+
for pat in patterns {
963+
self.visit_ty_pat(pat)
964+
}
965+
}
961966
TyPatKind::Err(_) => {}
962967
}
963968
}

0 commit comments

Comments
 (0)