Add pattern types to parser

Author: oli-obk

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -334,6 +334,9 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
             ast::TyKind::Never => {
                 gate!(&self, never_type, ty.span, "the `!` type is experimental");
             }
+            ast::TyKind::Pat(..) => {
+                gate!(&self, pattern_types, ty.span, "pattern types are unstable");
+            }
             _ => {}
         }
         visit::walk_ty(self, ty)

compiler/rustc_builtin_macros/src/lib.rs

@@ -45,6 +45,7 @@ mod format;
 mod format_foreign;
 mod global_allocator;
 mod log_syntax;
+mod pattern_type;
 mod source_util;
 mod test;
 mod trace_macros;
@@ -95,6 +96,7 @@ pub fn register_builtin_macros(resolver: &mut dyn ResolverExpand) {
         log_syntax: log_syntax::expand_log_syntax,
         module_path: source_util::expand_mod,
         option_env: env::expand_option_env,
+        pattern_type: pattern_type::expand,
         std_panic: edition_panic::expand_panic,
         stringify: source_util::expand_stringify,
         trace_macros: trace_macros::expand_trace_macros,

compiler/rustc_builtin_macros/src/pattern_type.rs

@@ -0,0 +1,30 @@
+use rustc_ast::{ast, ptr::P, tokenstream::TokenStream, Pat, Ty};
+use rustc_errors::PResult;
+use rustc_expand::base::{self, DummyResult, ExtCtxt};
+use rustc_span::{sym, Span};
+
+pub fn expand(
+    cx: &mut ExtCtxt<'_>,
+    sp: Span,
+    tts: TokenStream,
+) -> Box<dyn base::MacResult + 'static> {
+    let (ty, pat) = match parse_pat_ty(cx, tts) {
+        Ok(parsed) => parsed,
+        Err(err) => {
+            err.emit();
+            return DummyResult::any(sp);
+        }
+    };
+
+    base::MacEager::ty(cx.ty(sp, ast::TyKind::Pat(ty, pat)))
+}
+
+fn parse_pat_ty<'a>(cx: &mut ExtCtxt<'a>, stream: TokenStream) -> PResult<'a, (P<Ty>, P<Pat>)> {
+    let mut parser = cx.new_parser_from_tts(stream);
+
+    let ty = parser.parse_ty()?;
+    parser.eat_keyword(sym::is);
+    let pat = parser.parse_pat_no_top_alt(None, None)?;
+
+    Ok((ty, pat))
+}

compiler/rustc_feature/src/unstable.rs

@@ -554,6 +554,8 @@ declare_features! (
     (unstable, offset_of_nested, "CURRENT_RUSTC_VERSION", Some(120140)),
     /// Allows using `#[optimize(X)]`.
     (unstable, optimize_attribute, "1.34.0", Some(54882)),
+    /// Allows using pattern types.
+    (unstable, pattern_types, "CURRENT_RUSTC_VERSION", Some(54882)),
     /// Allows macro attributes on expressions, statements and non-inline modules.
     (unstable, proc_macro_hygiene, "1.30.0", Some(54727)),
     /// Allows `&raw const $place_expr` and `&raw mut $place_expr` expressions.

compiler/rustc_span/src/symbol.rs

@@ -909,6 +909,7 @@ symbols! {
         io_stderr,
         io_stdout,
         irrefutable_let_patterns,
+        is,
         isa_attribute,
         isize,
         issue,
@@ -1204,6 +1205,8 @@ symbols! {
         pat_param,
         path,
         pattern_parentheses,
+        pattern_type,
+        pattern_types,
         phantom_data,
         pic,
         pie,

library/core/src/lib.rs

@@ -380,6 +380,9 @@ pub mod net;
 pub mod option;
 pub mod panic;
 pub mod panicking;
+#[cfg(not(bootstrap))]
+#[unstable(feature = "core_pattern_types", issue = "none")]
+pub mod pat;
 pub mod pin;
 pub mod result;
 pub mod sync;

library/core/src/pat.rs

@@ -0,0 +1,14 @@
+//! Helper module for exporting the `pattern_type` macro
+
+/// Creates a pattern type.
+/// ```rust
+/// type Positive = pattern_type!(i32 is 1..);
+/// ```
+#[macro_export]
+#[rustc_builtin_macro(pattern_type)]
+#[unstable(feature = "core_pattern_type", issue = "none")]
+macro_rules! pattern_type {
+    ($($arg:tt)*) => {
+        /* compiler built-in */
+    };
+}

library/std/src/lib.rs

@@ -568,6 +568,9 @@ pub mod net;
 pub mod num;
 pub mod os;
 pub mod panic;
+#[cfg(not(bootstrap))]
+#[unstable(feature = "core_pattern_types", issue = "none")]
+pub mod pat;
 pub mod path;
 pub mod process;
 pub mod sync;

library/std/src/pat.rs

@@ -0,0 +1,3 @@
+//! Helper module for exporting the `pattern_type` macro
+
+pub use core::pattern_type;

tests/ui/type/pattern_types/bad_pat.rs

@@ -0,0 +1,12 @@
+// compile-flags: -Zno-analysis
+
+#![feature(pattern_types)]
+#![feature(core_pattern_types)]
+#![feature(core_pattern_type)]
+
+use std::pat::pattern_type;
+
+type NonNullU32_2 = pattern_type!(u32 is 1..=);
+//~^ ERROR: inclusive range with no end
+type Positive2 = pattern_type!(i32 is 0..=);
+//~^ ERROR: inclusive range with no end