separate messages for individual categories

Author: HTGAzureX1212

compiler/rustc_lint/messages.ftl

@@ -241,8 +241,20 @@ lint_hidden_unicode_codepoints = unicode codepoint changing visible direction of
 lint_identifier_non_ascii_char = identifier contains non-ASCII characters
 
 lint_identifier_uncommon_codepoints = identifier contains {$codepoints_len ->
-    [one] an uncommon Unicode codepoint
-    *[other] uncommon Unicode codepoints
+    [one] { $identifier_type ->
+        [Exclusion] an {$identifier_type} Unicode codepoint
+        [Technical] a {$identifier_type} Unicode codepoint
+        [Limited_Use] a {$identifier_type} Unicode codepoint
+        [Not_NFKC] a {$identifier_type} Unicode codepoint
+        *[other] an uncommon Unicode codepoint
+    }
+    *[other] { $identifier_type ->
+        [Exclusion] {$identifier_type} Unicode codepoints
+        [Technical] {$identifier_type} Unicode codepoints
+        [Limited_Use] {$identifier_type} Unicode codepoints
+        [Not_NFKC] {$identifier_type} Unicode codepoints
+        *[other] uncommon Unicode codepoints
+    }
 }: {$codepoints}
 
 lint_ignored_unless_crate_specified = {$level}({$name}) is ignored unless specified at crate level

compiler/rustc_lint/src/lib.rs

@@ -31,6 +31,7 @@
 #![feature(array_windows)]
 #![feature(box_patterns)]
 #![feature(control_flow_enum)]
+#![feature(extract_if)]
 #![feature(generic_nonzero)]
 #![feature(if_let_guard)]
 #![feature(iter_order_by)]

compiler/rustc_lint/src/lints.rs

@@ -1101,6 +1101,7 @@ pub struct IdentifierNonAsciiChar;
 pub struct IdentifierUncommonCodepoints {
     pub codepoints: Vec<char>,
     pub codepoints_len: usize,
+    pub identifier_type: String,
 }
 
 #[derive(LintDiagnostic)]

compiler/rustc_lint/src/non_ascii_idents.rs

@@ -7,6 +7,7 @@ use rustc_ast as ast;
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::unord::UnordMap;
 use rustc_span::symbol::Symbol;
+use unicode_security::general_security_profile::IdentifierType;
 
 declare_lint! {
     /// The `non_ascii_idents` lint detects non-ASCII identifiers.
@@ -189,17 +190,104 @@ impl EarlyLintPass for NonAsciiIdents {
             if check_uncommon_codepoints
                 && !symbol_str.chars().all(GeneralSecurityProfile::identifier_allowed)
             {
-                let codepoints: Vec<_> = symbol_str
-                    .chars()
-                    .filter(|c| !GeneralSecurityProfile::identifier_allowed(*c))
-                    .collect();
-                let codepoints_len = codepoints.len();
-
-                cx.emit_span_lint(
-                    UNCOMMON_CODEPOINTS,
-                    sp,
-                    IdentifierUncommonCodepoints { codepoints, codepoints_len },
-                );
+                let mut chars = symbol_str.chars().collect::<Vec<_>>();
+
+                let exclusion = chars
+                    .extract_if(|c| {
+                        GeneralSecurityProfile::identifier_type(*c)
+                            == Some(IdentifierType::Exclusion)
+                    })
+                    .collect::<Vec<_>>();
+                if !exclusion.is_empty() {
+                    let exclusion_len = exclusion.len();
+
+                    cx.emit_span_lint(
+                        UNCOMMON_CODEPOINTS,
+                        sp,
+                        IdentifierUncommonCodepoints {
+                            codepoints: exclusion,
+                            codepoints_len: exclusion_len,
+                            identifier_type: String::from("Exclusion"),
+                        },
+                    );
+                }
+
+                let technical = chars
+                    .extract_if(|c| {
+                        GeneralSecurityProfile::identifier_type(*c)
+                            == Some(IdentifierType::Technical)
+                    })
+                    .collect::<Vec<_>>();
+                if !technical.is_empty() {
+                    let technical_len = technical.len();
+
+                    cx.emit_span_lint(
+                        UNCOMMON_CODEPOINTS,
+                        sp,
+                        IdentifierUncommonCodepoints {
+                            codepoints: technical,
+                            codepoints_len: technical_len,
+                            identifier_type: String::from("Technical"),
+                        },
+                    );
+                }
+
+                let limited_use = chars
+                    .extract_if(|c| {
+                        GeneralSecurityProfile::identifier_type(*c)
+                            == Some(IdentifierType::Limited_Use)
+                    })
+                    .collect::<Vec<_>>();
+                if !limited_use.is_empty() {
+                    let limited_use_len = limited_use.len();
+
+                    cx.emit_span_lint(
+                        UNCOMMON_CODEPOINTS,
+                        sp,
+                        IdentifierUncommonCodepoints {
+                            codepoints: limited_use,
+                            codepoints_len: limited_use_len,
+                            identifier_type: String::from("Limited_Use"),
+                        },
+                    );
+                }
+
+                let not_nfkc = chars
+                    .extract_if(|c| {
+                        GeneralSecurityProfile::identifier_type(*c)
+                            == Some(IdentifierType::Not_NFKC)
+                    })
+                    .collect::<Vec<_>>();
+                if !not_nfkc.is_empty() {
+                    let not_nfkc_len = not_nfkc.len();
+
+                    cx.emit_span_lint(
+                        UNCOMMON_CODEPOINTS,
+                        sp,
+                        IdentifierUncommonCodepoints {
+                            codepoints: not_nfkc,
+                            codepoints_len: not_nfkc_len,
+                            identifier_type: String::from("Not_NFKC"),
+                        },
+                    );
+                }
+
+                let remaining = chars
+                    .extract_if(|c| !GeneralSecurityProfile::identifier_allowed(*c))
+                    .collect::<Vec<_>>();
+                if !remaining.is_empty() {
+                    let remaining_len = remaining.len();
+
+                    cx.emit_span_lint(
+                        UNCOMMON_CODEPOINTS,
+                        sp,
+                        IdentifierUncommonCodepoints {
+                            codepoints: remaining,
+                            codepoints_len: remaining_len,
+                            identifier_type: String::new(),
+                        },
+                    );
+                }
             }
         }
 

tests/ui/lint/rfc-2457-non-ascii-idents/lint-uncommon-codepoints.rs

@@ -1,9 +1,10 @@
 #![deny(uncommon_codepoints)]
 
-const µ: f64 = 0.000001; //~ ERROR identifier contains an uncommon Unicode codepoint
+const µ: f64 = 0.000001; //~ ERROR identifier contains a Not_NFKC Unicode codepoint: 'µ'
 //~| WARNING should have an upper case name
 
-fn dijkstra() {} //~ ERROR identifier contains an uncommon Unicode codepoint
+fn dijkstra() {}
+//~^ ERROR identifier contains a Not_NFKC Unicode codepoint: 'ij'
 
 fn main() {
     let ㇻㇲㇳ = "rust"; //~ ERROR identifier contains uncommon Unicode codepoints

tests/ui/lint/rfc-2457-non-ascii-idents/lint-uncommon-codepoints.stderr

@@ -1,4 +1,4 @@
-error: identifier contains an uncommon Unicode codepoint: 'µ'
+error: identifier contains a Not_NFKC Unicode codepoint: 'µ'
   --> $DIR/lint-uncommon-codepoints.rs:3:7
    |
 LL | const µ: f64 = 0.000001;
@@ -10,14 +10,14 @@ note: the lint level is defined here
 LL | #![deny(uncommon_codepoints)]
    |         ^^^^^^^^^^^^^^^^^^^
 
-error: identifier contains an uncommon Unicode codepoint: 'ij'
+error: identifier contains a Not_NFKC Unicode codepoint: 'ij'
   --> $DIR/lint-uncommon-codepoints.rs:6:4
    |
 LL | fn dijkstra() {}
    |    ^^^^^^^
 
 error: identifier contains uncommon Unicode codepoints: 'ㇻ', 'ㇲ', and 'ㇳ'
-  --> $DIR/lint-uncommon-codepoints.rs:9:9
+  --> $DIR/lint-uncommon-codepoints.rs:10:9
    |
 LL |     let ㇻㇲㇳ = "rust";
    |         ^^^^^^