Pattern types MVP

compiler/rustc_ast/src/ast.rs

@@ -2102,6 +2102,9 @@ pub enum TyKind {
     Err,
     /// Placeholder for a `va_list`.
     CVarArgs,
+    /// Pattern types like `u32 as 1..=`, which is the same as `NonZeroU32`,
+    /// just as part of the type system.
+    Pat(P<Ty>, P<Pat>),
 }
 
 impl TyKind {

compiler/rustc_ast/src/mut_visit.rs

@@ -476,6 +476,10 @@ pub fn noop_visit_ty<T: MutVisitor>(ty: &mut P<Ty>, vis: &mut T) {
         }
         TyKind::Tup(tys) => visit_vec(tys, |ty| vis.visit_ty(ty)),
         TyKind::Paren(ty) => vis.visit_ty(ty),
+        TyKind::Pat(ty, pat) => {
+            vis.visit_ty(ty);
+            vis.visit_pat(pat);
+        }
         TyKind::Path(qself, path) => {
             vis.visit_qself(qself);
             vis.visit_path(path);

compiler/rustc_ast/src/visit.rs

@@ -416,6 +416,10 @@ pub fn walk_ty<'a, V: Visitor<'a>>(visitor: &mut V, typ: &'a Ty) {
             }
             visitor.visit_path(path, typ.id);
         }
+        TyKind::Pat(ty, pat) => {
+            visitor.visit_ty(ty);
+            visitor.visit_pat(pat);
+        }
         TyKind::Array(ty, length) => {
             visitor.visit_ty(ty);
             visitor.visit_anon_const(length)

compiler/rustc_ast_lowering/src/lib.rs

@@ -1372,14 +1372,17 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     }
                 }
             }
-            TyKind::MacCall(_) => panic!("`TyKind::MacCall` should have been expanded by now"),
+            TyKind::MacCall(_) => {
+                span_bug!(t.span, "`TyKind::MacCall` should have been expanded by now")
+            }
             TyKind::CVarArgs => {
                 self.tcx.sess.delay_span_bug(
                     t.span,
                     "`TyKind::CVarArgs` should have been handled elsewhere",
                 );
                 hir::TyKind::Err
             }
+            TyKind::Pat(ty, pat) => hir::TyKind::Pat(self.lower_ty(ty, itctx), self.lower_pat(pat)),
         };
 
         hir::Ty { kind, span: self.lower_span(t.span), hir_id: self.lower_node_id(t.id) }

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -313,6 +313,9 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
             ast::TyKind::TraitObject(_, ast::TraitObjectSyntax::DynStar, ..) => {
                 gate_feature_post!(&self, dyn_star, ty.span, "dyn* trait objects are unstable");
             }
+            ast::TyKind::Pat(..) => {
+                gate_feature_post!(&self, pattern_types, ty.span, "pattern types are unstable");
+            }
             _ => {}
         }
         visit::walk_ty(self, ty)

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -1092,6 +1092,11 @@ impl<'a> State<'a> {
             ast::TyKind::CVarArgs => {
                 self.word("...");
             }
+            ast::TyKind::Pat(ty, pat) => {
+                self.print_type(ty);
+                self.word(" is ");
+                self.print_pat(pat);
+            }
         }
         self.end();
     }

compiler/rustc_feature/src/active.rs

@@ -477,6 +477,8 @@ declare_features! (
     (active, object_safe_for_dispatch, "1.40.0", Some(43561), None),
     /// Allows using `#[optimize(X)]`.
     (active, optimize_attribute, "1.34.0", Some(54882), None),
+    /// Allows using pattern types.
+    (active, pattern_types, "CURRENT_RUSTC_VERSION", Some(54882), None),
     /// Allows `extern "platform-intrinsic" { ... }`.
     (active, platform_intrinsics, "1.4.0", Some(27731), None),
     /// Allows using `#![plugin(myplugin)]`.

compiler/rustc_hir/src/hir.rs

@@ -2682,6 +2682,8 @@ pub enum TyKind<'hir> {
     Infer,
     /// Placeholder for a type that has failed to be defined.
     Err,
+    /// Pattern types (`u32 as 1..`)
+    Pat(&'hir Ty<'hir>, &'hir Pat<'hir>),
 }
 
 #[derive(Debug, HashStable_Generic)]

compiler/rustc_hir/src/intravisit.rs

@@ -845,6 +845,10 @@ pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty<'v>) {
         }
         TyKind::Typeof(ref expression) => visitor.visit_anon_const(expression),
         TyKind::Infer | TyKind::Err => {}
+        TyKind::Pat(ty, pat) => {
+            visitor.visit_ty(ty);
+            visitor.visit_pat(pat)
+        }
     }
 }
 

compiler/rustc_hir_analysis/src/astconv/mod.rs

@@ -2961,6 +2961,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                 // handled specially and will not descend into this routine.
                 self.ty_infer(None, ast_ty.span)
             }
+            hir::TyKind::Pat(..) => span_bug!(ast_ty.span, "{ast_ty:#?}"),
             hir::TyKind::Err => tcx.ty_error(),
         };
 

compiler/rustc_hir_pretty/src/lib.rs

@@ -366,6 +366,11 @@ impl<'a> State<'a> {
             hir::TyKind::Infer => {
                 self.word("_");
             }
+            hir::TyKind::Pat(ty, pat) => {
+                self.print_type(ty);
+                self.word(" is ");
+                self.print_pat(pat);
+            }
         }
         self.end()
     }

compiler/rustc_parse/src/parser/ty.rs

@@ -342,6 +342,12 @@ impl<'a> Parser<'a> {
         let span = lo.to(self.prev_token.span);
         let mut ty = self.mk_ty(span, kind);
 
+        if self.eat_keyword(sym::is) {
+            let pat = self.parse_pat_no_top_alt(None)?;
+            let span = lo.to(self.prev_token.span);
+            ty = self.mk_ty(span, TyKind::Pat(ty, pat));
+        }
+
         // Try to recover from use of `+` with incorrect priority.
         match allow_plus {
             AllowPlus::Yes => self.maybe_recover_from_bad_type_plus(&ty)?,

compiler/rustc_passes/src/hir_stats.rs

@@ -334,6 +334,7 @@ impl<'v> hir_visit::Visitor<'v> for StatCollector<'v> {
                 TraitObject,
                 Typeof,
                 Infer,
+                Pat,
                 Err
             ]
         );
@@ -586,6 +587,7 @@ impl<'v> ast_visit::Visitor<'v> for StatCollector<'v> {
                 Never,
                 Tup,
                 Path,
+                Pat,
                 TraitObject,
                 ImplTrait,
                 Paren,

compiler/rustc_save_analysis/src/sig.rs

@@ -322,7 +322,10 @@ impl<'hir> Sig for hir::Ty<'hir> {
                 let item = scx.tcx.hir().item(item_id);
                 item.make(offset, Some(item_id.hir_id()), scx)
             }
-            hir::TyKind::Typeof(_) | hir::TyKind::Infer | hir::TyKind::Err => Err("Ty"),
+            hir::TyKind::Pat(..)
+            | hir::TyKind::Typeof(_)
+            | hir::TyKind::Infer
+            | hir::TyKind::Err => Err("Ty"),
         }
     }
 }

compiler/rustc_span/src/symbol.rs

@@ -831,6 +831,7 @@ symbols! {
         intra_doc_pointers,
         intrinsics,
         irrefutable_let_patterns,
+        is,
         isa_attribute,
         isize,
         issue,
@@ -1076,6 +1077,7 @@ symbols! {
         pat_param,
         path,
         pattern_parentheses,
+        pattern_types,
         phantom_data,
         pin,
         platform_intrinsics,

src/librustdoc/clean/mod.rs

@@ -1609,6 +1609,7 @@ pub(crate) fn clean_ty<'tcx>(ty: &hir::Ty<'tcx>, cx: &mut DocContext<'tcx>) -> T
             BorrowedRef { lifetime, mutability: m.mutbl, type_: Box::new(clean_ty(m.ty, cx)) }
         }
         TyKind::Slice(ty) => Slice(Box::new(clean_ty(ty, cx))),
+        TyKind::Pat(ty, pat) => Type::Pat(Box::new(clean_ty(ty, cx)), format!("{pat:?}").into()),
         TyKind::Array(ty, ref length) => {
             let length = match length {
                 hir::ArrayLen::Infer(_, _) => "_".to_string(),

src/librustdoc/clean/types.rs

@@ -1602,7 +1602,9 @@ pub(crate) enum Type {
     ///
     /// This is mostly Rustdoc's version of [`hir::Path`].
     /// It has to be different because Rustdoc's [`PathSegment`] can contain cleaned generics.
-    Path { path: Path },
+    Path {
+        path: Path,
+    },
     /// A `dyn Trait` object: `dyn for<'a> Trait<'a> + Send + 'static`
     DynTrait(Vec<PolyTrait>, Option<Lifetime>),
     /// A type parameter.
@@ -1619,10 +1621,15 @@ pub(crate) enum Type {
     ///
     /// The `String` field is a stringified version of the array's length parameter.
     Array(Box<Type>, Box<str>),
+    Pat(Box<Type>, Box<str>),
     /// A raw pointer type: `*const i32`, `*mut i32`
     RawPointer(Mutability, Box<Type>),
     /// A reference type: `&i32`, `&'a mut Foo`
-    BorrowedRef { lifetime: Option<Lifetime>, mutability: Mutability, type_: Box<Type> },
+    BorrowedRef {
+        lifetime: Option<Lifetime>,
+        mutability: Mutability,
+        type_: Box<Type>,
+    },
 
     /// A qualified path to an associated item: `<Type as Trait>::Name`
     QPath(Box<QPathData>),
@@ -1747,6 +1754,7 @@ impl Type {
             BareFunction(..) => PrimitiveType::Fn,
             Slice(..) => PrimitiveType::Slice,
             Array(..) => PrimitiveType::Array,
+            Type::Pat(..) => PrimitiveType::Pat,
             RawPointer(..) => PrimitiveType::RawPointer,
             QPath(box QPathData { ref self_type, .. }) => return self_type.inner_def_id(cache),
             Generic(_) | Infer | ImplTrait(_) => return None,
@@ -1798,6 +1806,7 @@ pub(crate) enum PrimitiveType {
     Str,
     Slice,
     Array,
+    Pat,
     Tuple,
     Unit,
     RawPointer,
@@ -1945,6 +1954,7 @@ impl PrimitiveType {
             Bool => sym::bool,
             Char => sym::char,
             Array => sym::array,
+            Pat => sym::pat,
             Slice => sym::slice,
             Tuple => sym::tuple,
             Unit => sym::unit,

src/librustdoc/html/format.rs

@@ -1012,6 +1012,10 @@ fn fmt_type<'cx>(
                 write!(f, "]")
             }
         },
+        clean::Type::Pat(ref t, ref pat) => {
+            fmt::Display::fmt(&t.print(cx), f)?;
+            write!(f, " is {pat}")
+        }
         clean::Array(ref t, ref n) => match **t {
             clean::Generic(name) if !f.alternate() => primitive_link(
                 f,

src/librustdoc/html/render/search_index.rs

@@ -368,6 +368,7 @@ fn get_index_type_id(clean_type: &clean::Type) -> Option<RenderTypeId> {
         | clean::ImplTrait(_)
         | clean::Tuple(_)
         | clean::Slice(_)
+        | clean::Type::Pat(..)
         | clean::Array(_, _)
         | clean::QPath { .. }
         | clean::Infer => None,

src/librustdoc/json/conversions.rs

@@ -500,6 +500,9 @@ impl FromWithTcx<clean::Type> for Type {
             Tuple(t) => Type::Tuple(t.into_tcx(tcx)),
             Slice(t) => Type::Slice(Box::new((*t).into_tcx(tcx))),
             Array(t, s) => Type::Array { type_: Box::new((*t).into_tcx(tcx)), len: s.to_string() },
+            clean::Type::Pat(t, p) => {
+                Type::Pat { type_: Box::new((*t).into_tcx(tcx)), pat: p.to_string() }
+            }
             ImplTrait(g) => Type::ImplTrait(g.into_tcx(tcx)),
             Infer => Type::Infer,
             RawPointer(mutability, type_) => Type::RawPointer {

src/rustdoc-json-types/lib.rs

@@ -9,7 +9,7 @@ use std::path::PathBuf;
 use serde::{Deserialize, Serialize};
 
 /// rustdoc format-version.
-pub const FORMAT_VERSION: u32 = 24;
+pub const FORMAT_VERSION: u32 = 25;
 
 /// A `Crate` is the root of the emitted JSON blob. It contains all type/documentation information
 /// about the language items in the local crate, as well as info about external items to allow
@@ -565,6 +565,12 @@ pub enum Type {
         type_: Box<Type>,
         len: String,
     },
+    /// `u32 is 1..`
+    Pat {
+        #[serde(rename = "type")]
+        type_: Box<Type>,
+        pat: String,
+    },
     /// `impl TraitA + TraitB + ...`
     ImplTrait(Vec<GenericBound>),
     /// `_`

src/tools/clippy/clippy_lints/src/dereference.rs

@@ -1010,7 +1010,7 @@ fn binding_ty_auto_deref_stability<'tcx>(
                 }
             },
             TyKind::Slice(_) => Position::DerefStable(precedence, false),
-            TyKind::Array(..) | TyKind::Ptr(_) | TyKind::BareFn(_) => Position::DerefStable(precedence, true),
+            TyKind::Pat(..) | TyKind::Array(..) | TyKind::Ptr(_) | TyKind::BareFn(_) => Position::DerefStable(precedence, true),
             TyKind::Never
             | TyKind::Tup(_)
             | TyKind::Path(_) => Position::DerefStable(

src/tools/clippy/clippy_utils/src/hir_utils.rs

@@ -946,6 +946,10 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
                 self.hash_ty(ty);
                 self.hash_array_length(len);
             },
+            TyKind::Pat(ty, pat) => {
+                self.hash_ty(ty);
+                self.hash_pat(pat);
+            },
             TyKind::Ptr(ref mut_ty) => {
                 self.hash_ty(mut_ty.ty);
                 mut_ty.mutbl.hash(&mut self.s);

src/tools/rustfmt/src/types.rs

@@ -847,6 +847,11 @@ impl Rewrite for ast::Ty {
                 self.span,
                 shape,
             ),
+            ast::TyKind::Pat(ref ty, ref pat) => {
+                let ty = ty.rewrite(context, shape)?;
+                let pat = pat.rewrite(context, shape)?;
+                Some(format!("{ty} is {pat}"))
+            },
         }
     }
 }