feat(biome_js_analyzer): implement useConsistentMemberAccessibility (…

…#3536)

Co-authored-by: Victorien Elvinger <[email protected]>

CHANGELOG.md

@@ -13,6 +13,10 @@ our [guidelines for writing a good changelog entry](https://github.com/biomejs/b
 
 ### Analyzer
 
+#### New features
+
+- Implement [nursery/useConsistentMemberAccessibility](https://github.com/biomejs/biome/issues/3271). Contributed by @seitarof
+
 #### Enhancements
 
 - Implement [css suppression action](https://github.com/biomejs/biome/issues/3278). Contributed by @togami2864
@@ -322,6 +326,8 @@ our [guidelines for writing a good changelog entry](https://github.com/biomejs/b
 - Add [nursery/noUselessEscapeInRegex](https://biomejs.dev/linter/rules/no-useless-escape-in-regex/).
   Contributed by @Conaclos
 
+- Add [nursery/useConsistentMemberAccessibility](https://biomejs.dev/linter/rules/use-consistent-member-accessibility/). Contributed by @seitarof
+
 #### Enhancements
 
 - [noInvalidUseBeforeDeclaration](https://biomejs.dev/linter/rules/no-invalid-use-before-declaration) now reports direct use of an enum member before its declaration.

crates/biome_cli/src/execute/migrate/eslint_eslint.rs

@@ -494,6 +494,11 @@ impl Deserializable for Rules {
                                 result.insert(Rule::TypeScriptArrayType(conf));
                             }
                         }
+                        "@typescript-eslint/explicit-member-accessibility" => {
+                            if let Some(conf) = RuleConf::deserialize(&value, name, diagnostics) {
+                                result.insert(Rule::TypeScriptExplicitMemberAccessibility(conf));
+                            }
+                        }
                         "@typescript-eslint/naming-convention" => {
                             if let Some(conf) = RuleConf::deserialize(&value, name, diagnostics) {
                                 result.insert(Rule::TypeScriptNamingConvention(conf));
@@ -567,6 +572,9 @@ pub(crate) enum Rule {
     // Eslint plugins
     Jsxa11yArioaRoles(RuleConf<Box<eslint_jsxa11y::AriaRoleOptions>>),
     TypeScriptArrayType(RuleConf<eslint_typescript::ArrayTypeOptions>),
+    TypeScriptExplicitMemberAccessibility(
+        RuleConf<eslint_typescript::ExplicitMemberAccessibilityOptions>,
+    ),
     TypeScriptNamingConvention(RuleConf<Box<eslint_typescript::NamingConventionSelection>>),
     UnicornFilenameCase(RuleConf<eslint_unicorn::FilenameCaseOptions>),
     // If you add new variants, don't forget to update [Rules::deserialize].
@@ -578,6 +586,9 @@ impl Rule {
             Rule::NoRestrictedGlobals(_) => Cow::Borrowed("no-restricted-globals"),
             Rule::Jsxa11yArioaRoles(_) => Cow::Borrowed("jsx-a11y/aria-role"),
             Rule::TypeScriptArrayType(_) => Cow::Borrowed("@typescript-eslint/array-type"),
+            Rule::TypeScriptExplicitMemberAccessibility(_) => {
+                Cow::Borrowed("@typescript-eslint/explicit-member-accessibility")
+            }
             Rule::TypeScriptNamingConvention(_) => {
                 Cow::Borrowed("@typescript-eslint/naming-convention")
             }

crates/biome_cli/src/execute/migrate/eslint_to_biome.rs

@@ -252,6 +252,20 @@ fn migrate_eslint_rule(
                 }
             }
         }
+        eslint_eslint::Rule::TypeScriptExplicitMemberAccessibility(conf) => {
+            if migrate_eslint_any_rule(rules, &name, conf.severity(), opts, results) {
+                if let eslint_eslint::RuleConf::Option(severity, rule_options) = conf {
+                    let group = rules.nursery.get_or_insert_with(Default::default);
+                    group.use_consistent_member_accessibility =
+                        Some(biome_config::RuleConfiguration::WithOptions(
+                            biome_config::RuleWithOptions {
+                                level: severity.into(),
+                                options: rule_options.into(),
+                            },
+                        ));
+                }
+            }
+        }
         eslint_eslint::Rule::TypeScriptNamingConvention(conf) => {
             if migrate_eslint_any_rule(rules, &name, conf.severity(), opts, results) {
                 let severity = conf.severity();

crates/biome_cli/src/execute/migrate/eslint_typescript.rs

@@ -6,6 +6,7 @@ use std::{cmp::Ordering, str::FromStr};
 use biome_deserialize::Deserializable;
 use biome_deserialize_macros::Deserializable;
 use biome_js_analyze::{
+    lint::nursery::use_consistent_member_accessibility,
     lint::style::{use_consistent_array_type, use_naming_convention},
     utils::regex::RestrictedRegex,
 };
@@ -44,6 +45,38 @@ impl From<ArrayType> for use_consistent_array_type::ConsistentArrayType {
     }
 }
 
+#[derive(Debug, Default, Deserializable)]
+#[deserializable(unknown_fields = "allow")]
+pub(crate) struct ExplicitMemberAccessibilityOptions {
+    accessibility: Option<AccessibilityLevel>,
+}
+impl From<ExplicitMemberAccessibilityOptions>
+    for use_consistent_member_accessibility::ConsistentMemberAccessibilityOptions
+{
+    fn from(value: ExplicitMemberAccessibilityOptions) -> Self {
+        use_consistent_member_accessibility::ConsistentMemberAccessibilityOptions {
+            accessibility: value.accessibility.map(|x| x.into()).unwrap_or_default(),
+        }
+    }
+}
+#[derive(Clone, Copy, Debug, Default, Deserializable)]
+pub(crate) enum AccessibilityLevel {
+    #[default]
+    #[deserializable(rename = "no-public")]
+    NoPublic,
+    Explicit,
+    None,
+}
+impl From<AccessibilityLevel> for use_consistent_member_accessibility::Accessibility {
+    fn from(value: AccessibilityLevel) -> Self {
+        match value {
+            AccessibilityLevel::NoPublic => Self::NoPublic,
+            AccessibilityLevel::Explicit => Self::Explicit,
+            AccessibilityLevel::None => Self::None,
+        }
+    }
+}
+
 #[derive(Debug)]
 pub(crate) struct NamingConventionOptions(Vec<NamingConventionSelection>);
 impl NamingConventionOptions {