Add or-patterns to pattern types

Author: oli-obk

compiler/rustc_ast/src/ast.rs

@@ -2364,6 +2364,8 @@ pub enum TyPatKind {
     /// A range pattern (e.g., `1...2`, `1..2`, `1..`, `..2`, `1..=2`, `..=2`).
     Range(Option<P<AnonConst>>, Option<P<AnonConst>>, Spanned<RangeEnd>),
 
+    Or(ThinVec<P<TyPat>>),
+
     /// A `!null` pattern for raw pointers.
     NotNull,
 

compiler/rustc_ast/src/mut_visit.rs

@@ -609,6 +609,7 @@ pub fn walk_ty_pat<T: MutVisitor>(vis: &mut T, ty: &mut P<TyPat>) {
             visit_opt(start, |c| vis.visit_anon_const(c));
             visit_opt(end, |c| vis.visit_anon_const(c));
         }
+        TyPatKind::Or(variants) => visit_thin_vec(variants, |p| vis.visit_ty_pat(p)),
         TyPatKind::NotNull | TyPatKind::Err(_) => {}
     }
     visit_lazy_tts(vis, tokens);

compiler/rustc_ast/src/visit.rs

@@ -565,6 +565,7 @@ pub fn walk_ty_pat<'a, V: Visitor<'a>>(visitor: &mut V, tp: &'a TyPat) -> V::Res
             visit_opt!(visitor, visit_anon_const, start);
             visit_opt!(visitor, visit_anon_const, end);
         }
+        TyPatKind::Or(variants) => walk_list!(visitor, visit_ty_pat, variants),
         TyPatKind::NotNull | TyPatKind::Err(_) => {}
     }
     V::Result::output()

compiler/rustc_ast_lowering/src/pat.rs

@@ -465,6 +465,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         )
                     }),
             ),
+            TyPatKind::Or(variants) => {
+                hir::TyPatKind::Or(self.arena.alloc_from_iter(
+                    variants.iter().map(|pat| self.lower_ty_pat_mut(pat, base_type)),
+                ))
+            }
             TyPatKind::NotNull => hir::TyPatKind::NotNull,
             TyPatKind::Err(guar) => hir::TyPatKind::Err(*guar),
         };

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -1167,6 +1167,17 @@ impl<'a> State<'a> {
                     self.print_expr_anon_const(end, &[]);
                 }
             }
+            rustc_ast::TyPatKind::Or(variants) => {
+                let mut first = true;
+                for pat in variants {
+                    if first {
+                        first = false
+                    } else {
+                        self.word(" | ");
+                    }
+                    self.print_ty_pat(pat);
+                }
+            }
             rustc_ast::TyPatKind::NotNull => self.word("!null"),
             rustc_ast::TyPatKind::Err(_) => {
                 self.popen();

compiler/rustc_builtin_macros/src/pattern_type.rs

@@ -4,6 +4,7 @@ use rustc_ast::{AnonConst, DUMMY_NODE_ID, Ty, TyPat, TyPatKind, ast, token};
 use rustc_errors::PResult;
 use rustc_expand::base::{self, DummyResult, ExpandResult, ExtCtxt, MacroExpanderResult};
 use rustc_parse::exp;
+use rustc_parse::parser::{CommaRecoveryMode, RecoverColon, RecoverComma};
 use rustc_span::Span;
 
 pub(crate) fn expand<'cx>(
@@ -33,7 +34,17 @@ fn parse_pat_ty<'a>(cx: &mut ExtCtxt<'a>, stream: TokenStream) -> PResult<'a, (P
         let span = start.to(parser.token.span);
         ty_pat(TyPatKind::NotNull, span)
     } else {
-        pat_to_ty_pat(cx, parser.parse_pat_no_top_alt(None, None)?.into_inner())
+        pat_to_ty_pat(
+            cx,
+            parser
+                .parse_pat_no_top_guard(
+                    None,
+                    RecoverComma::No,
+                    RecoverColon::No,
+                    CommaRecoveryMode::EitherTupleOrPipe,
+                )?
+                .into_inner(),
+        )
     };
 
     if parser.token != token::Eof {
@@ -53,6 +64,9 @@ fn pat_to_ty_pat(cx: &mut ExtCtxt<'_>, pat: ast::Pat) -> P<TyPat> {
             end.map(|value| P(AnonConst { id: DUMMY_NODE_ID, value })),
             include_end,
         ),
+        ast::PatKind::Or(variants) => TyPatKind::Or(
+            variants.into_iter().map(|pat| pat_to_ty_pat(cx, pat.into_inner())).collect(),
+        ),
         ast::PatKind::Err(guar) => TyPatKind::Err(guar),
         _ => TyPatKind::Err(cx.dcx().span_err(pat.span, "pattern not supported in pattern types")),
     };

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -70,6 +70,9 @@ pub(crate) fn eval_nullary_intrinsic<'tcx>(
             ty::Pat(_, pat) => match **pat {
                 ty::PatternKind::Range { .. } => ConstValue::from_target_usize(0u64, &tcx),
                 ty::PatternKind::NotNull => ConstValue::from_target_usize(0_u64, &tcx),
+                // FIXME(pattern_types): make this report the number of distinct variants used in the
+                // or pattern in case the base type is an enum.
+                ty::PatternKind::Or(_) => ConstValue::from_target_usize(0_u64, &tcx),
             },
             ty::Bound(_, _) => bug!("bound ty during ctfe"),
             ty::Bool

compiler/rustc_const_eval/src/interpret/validity.rs

@@ -1249,6 +1249,10 @@ impl<'rt, 'tcx, M: Machine<'tcx>> ValueVisitor<'tcx, M> for ValidityVisitor<'rt,
                     // handled fully by `visit_scalar` (called below).
                     ty::PatternKind::Range { .. } => {},
                     ty::PatternKind::NotNull => {},
+
+                    // FIXME(pattern_types): check that the value is covered by one of the variants.
+                    // The layout may pessimistically cover actually illegal ranges.
+                    ty::PatternKind::Or(_patterns) => {}
                 }
             }
             _ => {

compiler/rustc_hir/src/hir.rs

@@ -1670,6 +1670,9 @@ pub enum TyPatKind<'hir> {
     /// A range pattern (e.g., `1..=2` or `1..2`).
     Range(&'hir ConstArg<'hir>, &'hir ConstArg<'hir>),
 
+    /// A list of patterns where only one needs to be satisfied
+    Or(&'hir [TyPat<'hir>]),
+
     /// A pattern that excludes null pointers
     NotNull,
 

compiler/rustc_hir/src/intravisit.rs

@@ -693,6 +693,7 @@ pub fn walk_ty_pat<'v, V: Visitor<'v>>(visitor: &mut V, pattern: &'v TyPat<'v>)
             try_visit!(visitor.visit_const_arg_unambig(lower_bound));
             try_visit!(visitor.visit_const_arg_unambig(upper_bound));
         }
+        TyPatKind::Or(patterns) => walk_list!(visitor, visit_pattern_type_pattern, patterns),
         TyPatKind::NotNull | TyPatKind::Err(_) => (),
     }
     V::Result::output()