Add not-null pointer patterns to pattern types

Author: oli-obk

compiler/rustc_ast/src/ast.rs

@@ -2294,6 +2294,9 @@ 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>),
 
+    /// A `!null` pattern for raw pointers.
+    NotNull,
+
     /// Placeholder for a pattern that wasn't syntactically well formed in some way.
     Err(ErrorGuaranteed),
 }

compiler/rustc_ast/src/mut_visit.rs

@@ -606,7 +606,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::Err(_) => {}
+        TyPatKind::NotNull | TyPatKind::Err(_) => {}
     }
     visit_lazy_tts(vis, tokens);
     vis.visit_span(span);

compiler/rustc_ast/src/visit.rs

@@ -565,7 +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::Err(_) => {}
+        TyPatKind::NotNull | TyPatKind::Err(_) => {}
     }
     V::Result::output()
 }

compiler/rustc_ast_lowering/src/pat.rs

@@ -142,7 +142,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     }
                     // return inner to be processed in next loop
                     PatKind::Paren(inner) => pattern = inner,
-                    PatKind::MacCall(_) => panic!("{:?} shouldn't exist here", pattern.span),
+                    PatKind::MacCall(_) => {
+                        panic!("{pattern:#?} shouldn't exist here")
+                    }
                     PatKind::Err(guar) => break hir::PatKind::Err(*guar),
                 }
             };
@@ -463,6 +465,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         )
                     }),
             ),
+            TyPatKind::NotNull => hir::TyPatKind::NotNull,
             TyPatKind::Err(guar) => hir::TyPatKind::Err(*guar),
         };
 

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -1166,6 +1166,7 @@ impl<'a> State<'a> {
                     self.print_expr_anon_const(end, &[]);
                 }
             }
+            rustc_ast::TyPatKind::NotNull => self.word("!null"),
             rustc_ast::TyPatKind::Err(_) => {
                 self.popen();
                 self.word("/*ERROR*/");

compiler/rustc_builtin_macros/src/pattern_type.rs

@@ -1,6 +1,6 @@
 use rustc_ast::ptr::P;
 use rustc_ast::tokenstream::TokenStream;
-use rustc_ast::{AnonConst, DUMMY_NODE_ID, Ty, TyPat, TyPatKind, ast};
+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;
@@ -26,19 +26,31 @@ fn parse_pat_ty<'a>(cx: &mut ExtCtxt<'a>, stream: TokenStream) -> PResult<'a, (P
 
     let ty = parser.parse_ty()?;
     parser.expect_keyword(exp!(Is))?;
-    let pat = parser.parse_pat_no_top_alt(None, None)?.into_inner();
 
-    let kind = match pat.kind {
-        ast::PatKind::Range(start, end, include_end) => TyPatKind::Range(
-            start.map(|value| P(AnonConst { id: DUMMY_NODE_ID, value })),
-            end.map(|value| P(AnonConst { id: DUMMY_NODE_ID, value })),
-            include_end,
-        ),
-        ast::PatKind::Err(guar) => TyPatKind::Err(guar),
-        _ => TyPatKind::Err(cx.dcx().span_err(pat.span, "pattern not supported in pattern types")),
+    let start = parser.token.span;
+    let kind = if parser.eat(exp!(Not)) {
+        parser.expect_keyword(exp!(Null))?;
+        TyPatKind::NotNull
+    } else {
+        let pat = parser.parse_pat_no_top_alt(None, None)?.into_inner();
+        match pat.kind {
+            ast::PatKind::Range(start, end, include_end) => TyPatKind::Range(
+                start.map(|value| P(AnonConst { id: DUMMY_NODE_ID, value })),
+                end.map(|value| P(AnonConst { id: DUMMY_NODE_ID, value })),
+                include_end,
+            ),
+            ast::PatKind::Err(guar) => TyPatKind::Err(guar),
+            _ => TyPatKind::Err(
+                cx.dcx().span_err(pat.span, "pattern not supported in pattern types"),
+            ),
+        }
     };
 
-    let pat = P(TyPat { id: pat.id, kind, span: pat.span, tokens: pat.tokens });
+    let span = start.to(parser.token.span);
+    let pat = P(TyPat { id: DUMMY_NODE_ID, kind, span, tokens: None });
 
+    if parser.token != token::Eof {
+        parser.unexpected()?;
+    }
     Ok((ty, pat))
 }

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -69,7 +69,7 @@ pub(crate) fn eval_nullary_intrinsic<'tcx>(
             }
             ty::Pat(_, pat) => match **pat {
                 ty::PatternKind::Range { .. } => ConstValue::from_target_usize(0u64, &tcx),
-                // Future pattern kinds may have more variants
+                ty::PatternKind::NotNull => ConstValue::from_target_usize(0_u64, &tcx),
             },
             ty::Bound(_, _) => bug!("bound ty during ctfe"),
             ty::Bool

compiler/rustc_const_eval/src/interpret/validity.rs

@@ -1248,6 +1248,7 @@ impl<'rt, 'tcx, M: Machine<'tcx>> ValueVisitor<'tcx, M> for ValidityVisitor<'rt,
                     // Range patterns are precisely reflected into `valid_range` and thus
                     // handled fully by `visit_scalar` (called below).
                     ty::PatternKind::Range { .. } => {},
+                    ty::PatternKind::NotNull => {},
                 }
             }
             _ => {

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 pattern that excludes null pointers
+    NotNull,
+
     /// A placeholder for a pattern that wasn't well formed in some way.
     Err(ErrorGuaranteed),
 }

compiler/rustc_hir/src/intravisit.rs

@@ -712,7 +712,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::Err(_) => (),
+        TyPatKind::NotNull | TyPatKind::Err(_) => (),
     }
     V::Result::output()
 }