Give type ascription a future compatibility report

Author: CAD97

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -5,7 +5,8 @@ use rustc_ast::{PatKind, RangeEnd, VariantData};
 use rustc_errors::{struct_span_err, Applicability, StashKey};
 use rustc_feature::Features;
 use rustc_feature::{AttributeGate, BuiltinAttribute, BUILTIN_ATTRIBUTE_MAP};
-use rustc_session::parse::{feature_err, feature_warn};
+use rustc_session::lint::builtin::TYPE_ASCRIPTION_SYNTAX;
+use rustc_session::parse::{feature_err, feature_force_warn, feature_warn};
 use rustc_session::Session;
 use rustc_span::source_map::Spanned;
 use rustc_span::symbol::sym;
@@ -640,7 +641,7 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
                     self.sess
                         .parse_sess
                         .span_diagnostic
-                        .steal_diagnostic(e.span, StashKey::EarlySyntaxWarning)
+                        .steal_diagnostic(e.span, StashKey::TypeAscriptionSyntax)
                         .map(|err| err.cancel());
                 }
             }
@@ -816,7 +817,16 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session) {
     gate_all!(exclusive_range_pattern, "exclusive range pattern syntax is experimental");
     gate_all!(try_blocks, "`try` blocks are unstable");
     gate_all!(box_syntax, "box expression syntax is experimental; you can call `Box::new` instead");
-    gate_all!(type_ascription, "type ascription is experimental");
+
+    // Type ascription has its own lint to participate in future-compatibility reports.
+    // Only create these lints if no other errors have been emitted to avoid overload.
+    if sess.parse_sess.span_diagnostic.err_count() == 0 {
+        if let Some(spans) = spans.get(&sym::type_ascription) {
+            for span in spans {
+                feature_force_warn(&visitor.sess.parse_sess, *span, TYPE_ASCRIPTION_SYNTAX);
+            }
+        }
+    }
 
     visit::walk_crate(&mut visitor, krate);
 }

compiler/rustc_errors/src/lib.rs

@@ -460,6 +460,7 @@ pub enum StashKey {
     ItemNoType,
     UnderscoreForArrayLengths,
     EarlySyntaxWarning,
+    TypeAscriptionSyntax,
 }
 
 fn default_track_diagnostic(_: &Diagnostic) {}

compiler/rustc_lint_defs/src/builtin.rs

@@ -3262,6 +3262,42 @@ declare_lint! {
     };
 }
 
+declare_lint! {
+    /// The `type_ascription_syntax` lint detects the use of the old type ascription
+    /// syntax which is going to be removed in the future. This syntax was previously
+    /// allowed accidentally, despite being unstable, and is now being phased out.
+    ///
+    /// ### Example
+    ///
+    /// ```rust
+    /// #[cfg(FALSE)]
+    /// let x = 1: u32;
+    /// ```
+    ///
+    /// {{produces}}
+    ///
+    /// ### Explanation
+    ///
+    /// The old type ascription syntax was accidentally allowed in the past, but
+    /// is now being phased out. The old syntax is too problematic to be stabilized
+    /// as-is, and causes an endless tail of diagnostics problems trying to distinguish
+    /// it from other syntax.
+    ///
+    ///
+    ///
+    /// This is a [future-incompatible] lint to transition this
+    /// to a hard error in the future. See [RFC #3307] for more details.
+    ///
+    /// [RFC #3307]: https://github.com/rust-lang/rfcs/pull/3307
+    /// [future-incompatible]: ../index.md#future-incompatible-lints
+    pub TYPE_ASCRIPTION_SYNTAX,
+    Deny,
+    "type ascription syntax is going to be removed in the future",
+    @future_incompatible = FutureIncompatibleInfo {
+        reference: "RFC #3307 <https://github.com/rust-lang/rfcs/pull/3307>",
+    };
+}
+
 declare_lint_pass! {
     /// Does nothing as a lint pass, but registers some `Lint`s
     /// that are used by other parts of the compiler.
@@ -3331,6 +3367,7 @@ declare_lint_pass! {
         NONTRIVIAL_STRUCTURAL_MATCH,
         SOFT_UNSTABLE,
         UNSTABLE_SYNTAX_PRE_EXPANSION,
+        TYPE_ASCRIPTION_SYNTAX,
         INLINE_NO_SANITIZE,
         BAD_ASM_STYLE,
         ASM_SUB_REGISTER,

compiler/rustc_session/src/parse.rs

@@ -155,6 +155,20 @@ pub fn feature_warn_issue<'a>(
     err.stash(span, StashKey::EarlySyntaxWarning);
 }
 
+pub fn feature_force_warn<'a>(sess: &'a ParseSess, span: Span, lint: &'static Lint) {
+    let future_incompatible = lint.future_incompatible.as_ref().unwrap();
+    let mut err = sess.span_diagnostic.struct_warn(lint.desc);
+    err.set_span(span);
+    err.code(DiagnosticId::Lint {
+        name: lint.name_lower(),
+        has_future_breakage: true,
+        is_force_warn: false,
+    });
+    err.note(format!("for more information, see {}", future_incompatible.reference));
+
+    err.stash(span, StashKey::TypeAscriptionSyntax);
+}
+
 /// Adds the diagnostics for a feature to an existing error.
 pub fn add_feature_diagnostics<'a>(err: &mut Diagnostic, sess: &'a ParseSess, feature: Symbol) {
     add_feature_diagnostics_for_issue(err, sess, feature, GateIssue::Language);

src/test/ui/consts/auxiliary/external_macro.rs

@@ -5,10 +5,9 @@
 // https://github.com/rust-lang/rust/issues/65300
 
 #[macro_export]
-#[allow_internal_unstable(type_ascription)]
 macro_rules! static_assert {
     ($test:expr) => {
         #[allow(dead_code)]
-        const _: () = [()][!($test: bool) as usize];
-    }
+        const _: () = [()][!($test as bool) as usize];
+    };
 }

src/test/ui/consts/const_in_pattern/accept_structural.rs

@@ -14,8 +14,6 @@
 
 // See also RFC 1445
 
-#![feature(type_ascription)]
-
 #[derive(Copy, Clone, Debug)]
 struct NoPartialEq(u32);
 
@@ -45,9 +43,6 @@ fn main() {
     const TUPLE: (OND, OND) = (None, None);
     match (None, None) { TUPLE => dbg!(TUPLE), _ => panic!("whoops"), };
 
-    const TYPE_ASCRIPTION: OND = None: OND;
-    match None { TYPE_ASCRIPTION => dbg!(TYPE_ASCRIPTION), _ => panic!("whoops"), };
-
     const ARRAY: [OND; 2] = [None, None];
     match [None; 2] { ARRAY => dbg!(ARRAY), _ => panic!("whoops"), };
 

src/test/ui/lint/unused/issue-88519-unused-paren.rs

@@ -2,7 +2,6 @@
 // Make sure unused parens lint doesn't emit a false positive.
 // See https://github.com/rust-lang/rust/issues/88519
 #![deny(unused_parens)]
-#![feature(type_ascription)]
 
 // binary ops are tested in issue-71290-unused-paren-binop.rs
 
@@ -49,27 +48,6 @@ mod casts {
     }
 }
 
-mod typeascription {
-    fn outside() -> u8 {
-        ({ 0 }): u8
-    }
-    fn inside() -> u8 {
-        ({ 0 }: u8)
-    }
-    fn outside_match() -> u8 {
-        (match 0 { x => x }): u8
-    }
-    fn inside_match() -> u8 {
-        (match 0 { x => x }: u8)
-    }
-    fn outside_if() -> u8 {
-        (if false { 0 } else { 0 }): u8
-    }
-    fn inside_if() -> u8 {
-        (if false { 0 } else { 0 }: u8)
-    }
-}
-
 mod index {
     fn outside(x: &[u8]) -> u8 {
         ({ x })[0]

src/test/ui/macros/stringify.rs

@@ -13,7 +13,6 @@
 #![feature(raw_ref_op)]
 #![feature(trait_alias)]
 #![feature(try_blocks)]
-#![feature(type_ascription)]
 #![deny(unused_macros)]
 
 macro_rules! stringify_block {
@@ -140,7 +139,9 @@ fn test_expr() {
 
     // ExprKind::Type
     assert_eq!(stringify_expr!(expr: T), "expr: T");
+    //~^ WARN: type ascription syntax is going to be removed
     assert_eq!(stringify_expr!(expr: T<u8>), "expr: T<u8>");
+    //~^ WARN: type ascription syntax is going to be removed
 
     // ExprKind::If
     assert_eq!(stringify_expr!(if true {}), "if true {}");

src/test/ui/macros/stringify.stderr

@@ -0,0 +1,36 @@
+warning: type ascription syntax is going to be removed in the future
+  --> $DIR/stringify.rs:141:32
+   |
+LL |     assert_eq!(stringify_expr!(expr: T), "expr: T");
+   |                                ^^^^^^^
+   |
+   = note: for more information, see RFC #3307 <https://github.com/rust-lang/rfcs/pull/3307>
+
+warning: type ascription syntax is going to be removed in the future
+  --> $DIR/stringify.rs:143:32
+   |
+LL |     assert_eq!(stringify_expr!(expr: T<u8>), "expr: T<u8>");
+   |                                ^^^^^^^^^^^
+   |
+   = note: for more information, see RFC #3307 <https://github.com/rust-lang/rfcs/pull/3307>
+
+warning: 2 warnings emitted
+
+Future incompatibility report: Future breakage diagnostic:
+warning: type ascription syntax is going to be removed in the future
+  --> $DIR/stringify.rs:141:32
+   |
+LL |     assert_eq!(stringify_expr!(expr: T), "expr: T");
+   |                                ^^^^^^^
+   |
+   = note: for more information, see RFC #3307 <https://github.com/rust-lang/rfcs/pull/3307>
+
+Future breakage diagnostic:
+warning: type ascription syntax is going to be removed in the future
+  --> $DIR/stringify.rs:143:32
+   |
+LL |     assert_eq!(stringify_expr!(expr: T<u8>), "expr: T<u8>");
+   |                                ^^^^^^^^^^^
+   |
+   = note: for more information, see RFC #3307 <https://github.com/rust-lang/rfcs/pull/3307>
+

src/test/ui/mir/mir_ascription_coercion.rs

@@ -16,9 +16,4 @@ fn main() {
     let index_deref_ref = &raw const ARRAY_REF[0];
     let deref_ref = &raw const *SLICE_REF;
     let index_deref_ref = &raw const SLICE_REF[1];
-
-    let x = 0;
-    let ascribe_ref = &raw const (x: i32);
-    let ascribe_deref = &raw const (*ARRAY_REF: [i32; 2]);
-    let ascribe_index_deref = &raw const (ARRAY_REF[0]: i32);
 }