Add refine attribute

Author: compiler-errors

compiler/rustc_feature/src/active.rs

@@ -529,6 +529,8 @@ declare_features! (
     (active, proc_macro_hygiene, "1.30.0", Some(54727), None),
     /// Allows `&raw const $place_expr` and `&raw mut $place_expr` expressions.
     (active, raw_ref_op, "1.41.0", Some(64490), None),
+    /// Allows use of the `#![refine]` attribute, and checks items for accidental refinements.
+    (incomplete, refine, "CURRENT_RUSTC_VERSION", Some(1), None),
     /// Allows using the `#[register_tool]` attribute.
     (active, register_tool, "1.41.0", Some(66079), None),
     /// Allows the `#[repr(i128)]` attribute for enums.

compiler/rustc_feature/src/builtin_attrs.rs

@@ -497,6 +497,9 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         experimental!(cfi_encoding)
     ),
 
+    // RFC 3245
+    gated!(refine, Normal, template!(Word), WarnFollowing, experimental!(refine)),
+
     // ==========================================================================
     // Internal attributes: Stability, deprecation, and unsafe:
     // ==========================================================================

compiler/rustc_lint_defs/src/builtin.rs

@@ -3436,6 +3436,7 @@ declare_lint_pass! {
         TYVAR_BEHIND_RAW_POINTER,
         UNCONDITIONAL_PANIC,
         UNCONDITIONAL_RECURSION,
+        UNDECLARED_REFINE,
         UNDEFINED_NAKED_FUNCTION_ABI,
         UNFULFILLED_LINT_EXPECTATIONS,
         UNINHABITED_STATIC,
@@ -4422,6 +4423,14 @@ declare_lint! {
     @feature_gate = sym::type_privacy_lints;
 }
 
+declare_lint! {
+    /// Refine
+    pub UNDECLARED_REFINE,
+    Warn,
+    "yeet",
+    @feature_gate = sym::refine;
+}
+
 declare_lint! {
     /// The `unknown_diagnostic_attributes` lint detects unrecognized diagnostic attributes.
     ///

compiler/rustc_passes/messages.ftl

@@ -52,6 +52,23 @@ passes_attr_only_on_main =
 passes_attr_only_on_root_main =
     `{$attr}` attribute can only be used on root `fn main()`
 
+passes_bad_refine_attr_assoc_const =
+    associated consts cannot be refined
+    .label = this associated const
+
+passes_bad_refine_attr_inherent_impl =
+    `#[refine]` attribute cannot be put on an item in an inherent impl
+    .note = the attribute is useless because the item does not refine anything
+    .label = this impl item
+
+passes_bad_refine_attr_other_item =
+    `#[refine]` attribute must be put on an associated function or type in a trait implementation
+    .label = this item
+passes_bad_refine_attr_trait =
+    `#[refine]` attribute cannot be put on an item in a trait
+    .note = the attribute is useless because the item does not refine anything
+    .label = this trait item
+
 passes_both_ffi_const_and_pure =
     `#[ffi_const]` function cannot be `#[ffi_pure]`
 

compiler/rustc_passes/src/check_attr.rs

@@ -183,6 +183,7 @@ impl CheckAttrVisitor<'_> {
                 | sym::rustc_allowed_through_unstable_modules
                 | sym::rustc_promotable => self.check_stability_promotable(&attr, span, target),
                 sym::link_ordinal => self.check_link_ordinal(&attr, span, target),
+                sym::refine => self.check_refine(&attr, span, target, hir_id),
                 sym::rustc_confusables => self.check_confusables(&attr, target),
                 _ => true,
             };
@@ -2304,6 +2305,37 @@ impl CheckAttrVisitor<'_> {
             self.abort.set(true);
         }
     }
+
+    fn check_refine(&self, attr: &Attribute, span: Span, target: Target, hir_id: HirId) -> bool {
+        let attr_span = attr.span;
+        match target {
+            Target::Method(_) | Target::AssocTy => {
+                let parent_def_id = self.tcx.hir().get_parent_item(hir_id).def_id;
+                match self.tcx.hir().expect_item(parent_def_id).kind {
+                    hir::ItemKind::Impl(impl_) if impl_.of_trait.is_some() => true,
+                    hir::ItemKind::Impl(..) => {
+                        self.tcx
+                            .sess
+                            .emit_err(errors::BadRefineAttr::InherentImpl { span, attr_span });
+                        false
+                    }
+                    hir::ItemKind::Trait(..) => {
+                        self.tcx.sess.emit_err(errors::BadRefineAttr::Trait { span, attr_span });
+                        false
+                    }
+                    _ => unreachable!("only expect assoc ty and method on trait/impl"),
+                }
+            }
+            Target::AssocConst => {
+                self.tcx.sess.emit_err(errors::BadRefineAttr::AssocConst { span, attr_span });
+                false
+            }
+            _ => {
+                self.tcx.sess.emit_err(errors::BadRefineAttr::OtherItem { span, attr_span });
+                false
+            }
+        }
+    }
 }
 
 impl<'tcx> Visitor<'tcx> for CheckAttrVisitor<'tcx> {

compiler/rustc_passes/src/errors.rs

@@ -1757,3 +1757,37 @@ pub struct AttrCrateLevelOnlySugg {
     #[primary_span]
     pub attr: Span,
 }
+
+#[derive(Diagnostic)]
+pub enum BadRefineAttr {
+    #[diag(passes_bad_refine_attr_inherent_impl)]
+    #[note]
+    InherentImpl {
+        #[primary_span]
+        attr_span: Span,
+        #[label]
+        span: Span,
+    },
+    #[diag(passes_bad_refine_attr_trait)]
+    #[note]
+    Trait {
+        #[primary_span]
+        attr_span: Span,
+        #[label]
+        span: Span,
+    },
+    #[diag(passes_bad_refine_attr_assoc_const)]
+    AssocConst {
+        #[primary_span]
+        attr_span: Span,
+        #[label]
+        span: Span,
+    },
+    #[diag(passes_bad_refine_attr_other_item)]
+    OtherItem {
+        #[primary_span]
+        attr_span: Span,
+        #[label]
+        span: Span,
+    },
+}

compiler/rustc_span/src/symbol.rs

@@ -1201,6 +1201,7 @@ symbols! {
         reexport_test_harness_main,
         ref_unwind_safe_trait,
         reference,
+        refine,
         reflect,
         reg,
         reg16,

tests/ui/feature-gates/feature-gate-refine.rs

@@ -0,0 +1,11 @@
+trait Foo {
+    fn assoc();
+}
+
+impl Foo for () {
+    #[refine]
+    //~^ ERROR the `#[refine]` attribute is an experimental feature
+    fn assoc() {}
+}
+
+fn main() {}

tests/ui/feature-gates/feature-gate-refine.stderr

@@ -0,0 +1,12 @@
+error[E0658]: the `#[refine]` attribute is an experimental feature
+  --> $DIR/feature-gate-refine.rs:6:5
+   |
+LL |     #[refine]
+   |     ^^^^^^^^^
+   |
+   = note: see issue #1 <https://github.com/rust-lang/rust/issues/1> for more information
+   = help: add `#![feature(refine)]` to the crate attributes to enable
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0658`.

tests/ui/rfcs/rfc-3245-refined-impls/attr.rs

@@ -0,0 +1,44 @@
+#![feature(refine)]
+
+trait Foo {
+    #[refine]
+    //~^ ERROR `#[refine]` attribute cannot be put on an item in a trait
+    fn assoc();
+
+    #[refine]
+    //~^ ERROR `#[refine]` attribute cannot be put on an item in a trait
+    type Assoc;
+
+    #[refine]
+    //~^ ERROR associated consts cannot be refined
+    const N: u32;
+}
+
+struct W;
+impl W {
+    #[refine]
+    //~^ ERROR `#[refine]` attribute cannot be put on an item in an inherent impl
+    fn assoc() {}
+
+    #[refine]
+    //~^ ERROR associated consts cannot be refined
+    const M: u32 = 1;
+}
+
+impl Foo for W {
+    #[refine]
+    //~^ ERROR associated consts cannot be refined
+    const N: u32 = 1;
+
+    #[refine]
+    fn assoc() {} // Ok
+
+    #[refine]
+    type Assoc = (); // Ok
+}
+
+#[refine]
+//~^ ERROR `#[refine]` attribute must be put on an associated function or type in a trait implementation
+fn foo() {}
+
+fn main() {}