[ty] Allow overriding rules for specific files (#18648)

Author: MichaReiser

Cargo.lock

@@ -668,6 +668,73 @@ pub enum DiagnosticId {
 
     /// A glob pattern doesn't follow the expected syntax.
     InvalidGlob,
+
+    /// An `include` glob without any patterns.
+    ///
+    /// ## Why is this bad?
+    /// An `include` glob without any patterns won't match any files. This is probably a mistake and
+    /// either the `include` should be removed or a pattern should be added.
+    ///
+    /// ## Example
+    /// ```toml
+    /// [src]
+    /// include = []
+    /// ```
+    ///
+    /// Use instead:
+    ///
+    /// ```toml
+    /// [src]
+    /// include = ["src"]
+    /// ```
+    ///
+    /// or remove the `include` option.
+    EmptyInclude,
+
+    /// An override configuration is unnecessary because it applies to all files.
+    ///
+    /// ## Why is this bad?
+    /// An overrides section that applies to all files is probably a mistake and can be rolled-up into the root configuration.
+    ///
+    /// ## Example
+    /// ```toml
+    /// [[overrides]]
+    /// [overrides.rules]
+    /// unused-reference = "ignore"
+    /// ```
+    ///
+    /// Use instead:
+    ///
+    /// ```toml
+    /// [rules]
+    /// unused-reference = "ignore"
+    /// ```
+    ///
+    /// or
+    ///
+    /// ```toml
+    /// [[overrides]]
+    /// include = ["test"]
+    ///
+    /// [overrides.rules]
+    /// unused-reference = "ignore"
+    /// ```
+    UnnecessaryOverridesSection,
+
+    /// An `overrides` section in the configuration that doesn't contain any overrides.
+    ///
+    /// ## Why is this bad?
+    /// An `overrides` section without any configuration overrides is probably a mistake.
+    /// It is either a leftover after removing overrides, or a user forgot to add any overrides,
+    /// or used an incorrect syntax to do so (e.g. used `rules` instead of `overrides.rules`).
+    ///
+    /// ## Example
+    /// ```toml
+    /// [[overrides]]
+    /// include = ["test"]
+    /// # no `[overrides.rules]`
+    /// ```
+    UselessOverridesSection,
 }
 
 impl DiagnosticId {
@@ -703,6 +770,9 @@ impl DiagnosticId {
             DiagnosticId::RevealedType => "revealed-type",
             DiagnosticId::UnknownRule => "unknown-rule",
             DiagnosticId::InvalidGlob => "invalid-glob",
+            DiagnosticId::EmptyInclude => "empty-include",
+            DiagnosticId::UnnecessaryOverridesSection => "unnecessary-overrides-section",
+            DiagnosticId::UselessOverridesSection => "useless-overrides-section",
         }
     }
 

crates/ruff_db/src/diagnostic/mod.rs

@@ -59,6 +59,13 @@ pub fn max_parallelism() -> NonZeroUsize {
         })
 }
 
+/// Trait for types that can provide Rust documentation.
+///
+/// Use `derive(RustDoc)` to automatically implement this trait for types that have a static string documentation.
+pub trait RustDoc {
+    fn rust_doc() -> &'static str;
+}
+
 #[cfg(test)]
 mod tests {
     use std::sync::{Arc, Mutex};

crates/ruff_db/src/lib.rs

@@ -92,7 +92,7 @@ impl Db for ModuleDb {
         !file.path(self).is_vendored_path()
     }
 
-    fn rule_selection(&self) -> &RuleSelection {
+    fn rule_selection(&self, _file: File) -> &RuleSelection {
         &self.rule_selection
     }
 

crates/ruff_graph/src/db.rs

@@ -16,6 +16,7 @@ mod map_codes;
 mod newtype_index;
 mod rule_code_prefix;
 mod rule_namespace;
+mod rust_doc;
 mod violation_metadata;
 
 #[proc_macro_derive(OptionsMetadata, attributes(option, doc, option_group))]
@@ -27,6 +28,15 @@ pub fn derive_options_metadata(input: TokenStream) -> TokenStream {
         .into()
 }
 
+#[proc_macro_derive(RustDoc)]
+pub fn derive_rust_doc(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+
+    rust_doc::derive_impl(input)
+        .unwrap_or_else(syn::Error::into_compile_error)
+        .into()
+}
+
 #[proc_macro_derive(CombineOptions)]
 pub fn derive_combine_options(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as DeriveInput);

crates/ruff_macros/src/lib.rs

@@ -0,0 +1,62 @@
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{Attribute, DeriveInput, Error, Lit, LitStr, Meta};
+
+pub(crate) fn derive_impl(input: DeriveInput) -> syn::Result<TokenStream> {
+    let docs = get_docs(&input.attrs)?;
+
+    let name = input.ident;
+
+    let (impl_generics, ty_generics, where_clause) = &input.generics.split_for_impl();
+
+    Ok(quote! {
+        #[automatically_derived]
+        impl #impl_generics ruff_db::RustDoc for #name #ty_generics #where_clause {
+            fn rust_doc() -> &'static str {
+                #docs
+            }
+        }
+    })
+}
+/// Collect all doc comment attributes into a string
+fn get_docs(attrs: &[Attribute]) -> syn::Result<String> {
+    let mut explanation = String::new();
+    for attr in attrs {
+        if attr.path().is_ident("doc") {
+            if let Some(lit) = parse_attr(["doc"], attr) {
+                let value = lit.value();
+                // `/// ` adds
+                let line = value.strip_prefix(' ').unwrap_or(&value);
+                explanation.push_str(line);
+                explanation.push('\n');
+            } else {
+                return Err(Error::new_spanned(attr, "unimplemented doc comment style"));
+            }
+        }
+    }
+    Ok(explanation)
+}
+
+fn parse_attr<'a, const LEN: usize>(
+    path: [&'static str; LEN],
+    attr: &'a Attribute,
+) -> Option<&'a LitStr> {
+    if let Meta::NameValue(name_value) = &attr.meta {
+        let path_idents = name_value
+            .path
+            .segments
+            .iter()
+            .map(|segment| &segment.ident);
+
+        if path_idents.eq(path) {
+            if let syn::Expr::Lit(syn::ExprLit {
+                lit: Lit::Str(lit), ..
+            }) = &name_value.value
+            {
+                return Some(lit);
+            }
+        }
+    }
+
+    None
+}

crates/ruff_macros/src/rust_doc.rs

@@ -205,14 +205,17 @@ impl CheckCommand {
             src: Some(SrcOptions {
                 respect_ignore_files,
                 exclude: self.exclude.map(|excludes| {
-                    excludes
-                        .iter()
-                        .map(|exclude| RelativeExcludePattern::cli(exclude))
-                        .collect()
+                    RangedValue::cli(
+                        excludes
+                            .iter()
+                            .map(|exclude| RelativeExcludePattern::cli(exclude))
+                            .collect(),
+                    )
                 }),
                 ..SrcOptions::default()
             }),
             rules,
+            ..Options::default()
         };
         // Merge with options passed in via --config
         options.combine(self.config.into_options().unwrap_or_default())