Add pattern types to parser

Author: oli-obk

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_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_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_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/tools/tidy/src/features.rs

@@ -14,7 +14,7 @@ use std::collections::hash_map::{Entry, HashMap};
 use std::fmt;
 use std::fs;
 use std::num::NonZeroU32;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 
 use regex::Regex;
 
@@ -51,6 +51,8 @@ pub struct Feature {
     pub since: Option<Version>,
     pub has_gate_test: bool,
     pub tracking_issue: Option<NonZeroU32>,
+    pub file: PathBuf,
+    pub line: usize,
 }
 impl Feature {
     fn tracking_issue_display(&self) -> impl fmt::Display {
@@ -72,7 +74,7 @@ pub struct CollectedFeatures {
 pub fn collect_lib_features(base_src_path: &Path) -> Features {
     let mut lib_features = Features::new();
 
-    map_lib_features(base_src_path, &mut |res, _, _| {
+    map_lib_features(base_src_path, &mut |res| {
         if let Ok((name, feature)) = res {
             lib_features.insert(name.to_owned(), feature);
         }
@@ -185,23 +187,25 @@ pub fn check(
         .chain(lib_features.iter().map(|feat| (feat, "lib")));
     for ((feature_name, feature), kind) in all_features_iter {
         let since = if let Some(since) = feature.since { since } else { continue };
+        let file = feature.file.display();
+        let line = feature.line;
         if since > version && since != Version::CurrentPlaceholder {
             tidy_error!(
                 bad,
-                "The stabilization version {since} of {kind} feature `{feature_name}` is newer than the current {version}"
+                "{file}:{line}: The stabilization version {since} of {kind} feature `{feature_name}` is newer than the current {version}"
             );
         }
         if channel == "nightly" && since == version {
             tidy_error!(
                 bad,
-                "The stabilization version {since} of {kind} feature `{feature_name}` is written out but should be {}",
+                "{file}:{line}: The stabilization version {since} of {kind} feature `{feature_name}` is written out but should be {}",
                 version::VERSION_PLACEHOLDER
             );
         }
         if channel != "nightly" && since == Version::CurrentPlaceholder {
             tidy_error!(
                 bad,
-                "The placeholder use of {kind} feature `{feature_name}` is not allowed on the {channel} channel",
+                "{file}:{line}: The placeholder use of {kind} feature `{feature_name}` is not allowed on the {channel} channel",
             );
         }
     }
@@ -435,7 +439,14 @@ fn collect_lang_features_in(features: &mut Features, base: &Path, file: &str, ba
                 );
             }
             Entry::Vacant(e) => {
-                e.insert(Feature { level, since, has_gate_test: false, tracking_issue });
+                e.insert(Feature {
+                    level,
+                    since,
+                    has_gate_test: false,
+                    tracking_issue,
+                    file: path.to_path_buf(),
+                    line: line_number,
+                });
             }
         }
     }
@@ -447,16 +458,16 @@ fn get_and_check_lib_features(
     lang_features: &Features,
 ) -> Features {
     let mut lib_features = Features::new();
-    map_lib_features(base_src_path, &mut |res, file, line| match res {
+    map_lib_features(base_src_path, &mut |res| match res {
         Ok((name, f)) => {
             let mut check_features = |f: &Feature, list: &Features, display: &str| {
                 if let Some(ref s) = list.get(name) {
                     if f.tracking_issue != s.tracking_issue && f.level != Status::Stable {
                         tidy_error!(
                             bad,
                             "{}:{}: `issue` \"{}\" mismatches the {} `issue` of \"{}\"",
-                            file.display(),
-                            line,
+                            f.file.display(),
+                            f.line,
                             f.tracking_issue_display(),
                             display,
                             s.tracking_issue_display(),
@@ -468,7 +479,7 @@ fn get_and_check_lib_features(
             check_features(&f, &lib_features, "previous");
             lib_features.insert(name.to_owned(), f);
         }
-        Err(msg) => {
+        Err((msg, file, line)) => {
             tidy_error!(bad, "{}:{}: {}", file.display(), line, msg);
         }
     });
@@ -477,7 +488,7 @@ fn get_and_check_lib_features(
 
 fn map_lib_features(
     base_src_path: &Path,
-    mf: &mut dyn FnMut(Result<(&str, Feature), &str>, &Path, usize),
+    mf: &mut dyn FnMut(Result<(&str, Feature), (&str, &Path, usize)>),
 ) {
     walk(
         base_src_path,
@@ -514,7 +525,7 @@ fn map_lib_features(
             while let Some((i, line)) = iter_lines.next() {
                 macro_rules! err {
                     ($msg:expr) => {{
-                        mf(Err($msg), file, i + 1);
+                        mf(Err(($msg, file, i + 1)));
                         continue;
                     }};
                 }
@@ -532,7 +543,10 @@ fn map_lib_features(
                         f.tracking_issue = find_attr_val(line, "issue").and_then(handle_issue_none);
                     }
                     if line.ends_with(']') {
-                        mf(Ok((name, f.clone())), file, i + 1);
+                        let mut f = f.clone();
+                        f.file = file.to_path_buf();
+                        f.line = i + 1;
+                        mf(Ok((name, f)));
                     } else if !line.ends_with(',') && !line.ends_with('\\') && !line.ends_with('"')
                     {
                         // We need to bail here because we might have missed the
@@ -561,8 +575,10 @@ fn map_lib_features(
                         since: None,
                         has_gate_test: false,
                         tracking_issue: find_attr_val(line, "issue").and_then(handle_issue_none),
+                        file: file.to_path_buf(),
+                        line: i + 1,
                     };
-                    mf(Ok((feature_name, feature)), file, i + 1);
+                    mf(Ok((feature_name, feature)));
                     continue;
                 }
                 let level = if line.contains("[unstable(") {
@@ -590,9 +606,16 @@ fn map_lib_features(
                 };
                 let tracking_issue = find_attr_val(line, "issue").and_then(handle_issue_none);
 
-                let feature = Feature { level, since, has_gate_test: false, tracking_issue };
+                let feature = Feature {
+                    level,
+                    since,
+                    has_gate_test: false,
+                    tracking_issue,
+                    file: file.to_path_buf(),
+                    line: i + 1,
+                };
                 if line.contains(']') {
-                    mf(Ok((feature_name, feature)), file, i + 1);
+                    mf(Ok((feature_name, feature)));
                 } else {
                     becoming_feature = Some((feature_name, feature));
                 }

tests/ui/const-generics/bad-const-generic-exprs.stderr

@@ -142,11 +142,11 @@ help: expressions must be enclosed in braces to be used as const generic argumen
 LL |     let _: Wow<{ (1 + 2) * 3 }>;
    |                +             +
 
-error: expected one of `,` or `>`, found `0`
+error: expected one of `,`, `>`, or `is`, found `0`
   --> $DIR/bad-const-generic-exprs.rs:43:17
    |
 LL |     let _: Wow<!0>;
-   |         -       ^ expected one of `,` or `>`
+   |         -       ^ expected one of `,`, `>`, or `is`
    |         |
    |         while parsing the type for `_`
    |

tests/ui/fn/fn-recover-return-sign2.rs

@@ -3,6 +3,6 @@
 
 fn foo() => impl Fn() => bool {
     //~^ ERROR return types are denoted using `->`
-    //~| ERROR expected one of `+`, `->`, `::`, `where`, or `{`, found `=>`
+    //~| ERROR expected one of `+`, `->`, `::`, `is`, `where`, or `{`, found `=>`
     unimplemented!()
 }

tests/ui/fn/fn-recover-return-sign2.stderr

@@ -4,11 +4,11 @@ error: return types are denoted using `->`
 LL | fn foo() => impl Fn() => bool {
    |          ^^ help: use `->` instead
 
-error: expected one of `+`, `->`, `::`, `where`, or `{`, found `=>`
+error: expected one of `+`, `->`, `::`, `is`, `where`, or `{`, found `=>`
   --> $DIR/fn-recover-return-sign2.rs:4:23
    |
 LL | fn foo() => impl Fn() => bool {
-   |                       ^^ expected one of `+`, `->`, `::`, `where`, or `{`
+   |                       ^^ expected one of `+`, `->`, `::`, `is`, `where`, or `{`
 
 error: aborting due to 2 previous errors
 

tests/ui/generic-associated-types/parse/trait-path-expected-token.rs

@@ -3,6 +3,6 @@ trait X {
 }
 
 fn f1<'a>(arg : Box<dyn X<Y = B = &'a ()>>) {}
-    //~^ ERROR: expected one of `!`, `(`, `+`, `,`, `::`, `<`, or `>`, found `=`
+    //~^ ERROR: expected one of `!`, `(`, `+`, `,`, `::`, `<`, `>`, or `is`, found `=`
 
 fn main() {}

tests/ui/generic-associated-types/parse/trait-path-expected-token.stderr

@@ -1,8 +1,8 @@
-error: expected one of `!`, `(`, `+`, `,`, `::`, `<`, or `>`, found `=`
+error: expected one of `!`, `(`, `+`, `,`, `::`, `<`, `>`, or `is`, found `=`
   --> $DIR/trait-path-expected-token.rs:5:33
    |
 LL | fn f1<'a>(arg : Box<dyn X<Y = B = &'a ()>>) {}
-   |                               - ^ expected one of 7 possible tokens
+   |                               - ^ expected one of 8 possible tokens
    |                               |
    |                               maybe try to close unmatched angle bracket