name: explicit-member-accessibility rule
overview: Implement the typescript/explicit-member-accessibility rule that requires (or forbids) explicit public/private/protected modifiers on class members, with per-member-kind overrides and autofix support.
todos:

• id: scaffold
  content: Run just new-typescript-rule explicit-member-accessibility to generate boilerplate and register the rule
  status: completed
• id: config
  content: Define AccessibilityLevel enum, config struct with accessibility, ignoredMethodNames, overrides, and implement from_configuration
  status: completed
• id: diagnostics
  content: Define missing_accessibility and unwanted_public_accessibility diagnostic helper functions
  status: completed
• id: run-methods
  content: Implement Rule::run for MethodDefinition -- check constructors, methods, getters/setters with correct override resolution
  status: completed
• id: run-properties
  content: Implement Rule::run for PropertyDefinition and AccessorProperty
  status: completed
• id: run-params
  content: Implement Rule::run for FormalParameter (parameter properties)
  status: completed
• id: fixes
  content: Implement fix (remove public) and suggestions (add public/private/protected)
  status: completed
• id: tests
  content: Add comprehensive test cases covering all config permutations, member types, private identifiers, and fixes
  status: completed
• id: finalize
  content: Run just fmt, cargo test -p oxc_linter, and just ready
  status: completed
  isProject: false

Implement typescript/explicit-member-accessibility

Reference

• typescript-eslint docs: https://typescript-eslint.io/rules/explicit-member-accessibility
• Upstream source: explicit-member-accessibility.ts

Rule behavior

The rule has three accessibility-level modes:

• "explicit" (default) -- every class member must have an explicit public, private, or protected modifier
• "no-public" -- the public keyword is forbidden (the other two are fine)
• "off" -- no checking

A top-level accessibility option sets the default. Per-member-kind overrides can specialize behavior for: constructors, methods, accessors, properties, parameterProperties.

An ignoredMethodNames option (string array) skips named methods.

Fixes:

• "no-public" violations get a fix that removes the public keyword
• "explicit" violations get suggestions (not auto-fix) offering to add public, private, or protected

Members with #private identifier keys are always skipped (JS private fields already have inherent privacy).

Key AST types

All live in crates/oxc_ast/src/ast/js.rs and crates/oxc_ast/src/ast/ts.rs:

• MethodDefinition -- has accessibility: Option<TSAccessibility>, kind: MethodDefinitionKind, key: PropertyKey
• PropertyDefinition -- has accessibility: Option<TSAccessibility>, key: PropertyKey
• AccessorProperty -- has accessibility: Option<TSAccessibility>, key: PropertyKey
• FormalParameter -- has accessibility: Option<TSAccessibility>, readonly: bool, has_modifier() (parameter properties)
• TSAccessibility -- enum: Public, Protected, Private
• PropertyKey::is_private_identifier() -- detect #foo private fields

Implementation plan

1. Scaffold with just new-typescript-rule

just new-typescript-rule explicit-member-accessibility

This generates crates/oxc_linter/src/rules/typescript/explicit_member_accessibility.rs, registers the module in crates/oxc_linter/src/rules.rs, and runs codegen.

2. Define config struct

In the new rule file, define the configuration following the pattern in no_extraneous_class.rs:

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum AccessibilityLevel { Explicit, NoPublic, Off }

#[derive(Debug, Clone, Default, JsonSchema)]
#[serde(rename_all = "camelCase", default)]
pub struct ExplicitMemberAccessibility {
    accessibility: AccessibilityLevel, // default: Explicit
    ignored_method_names: Vec<String>,
    overrides: AccessibilityOverrides,
}

#[derive(Debug, Clone, Default, JsonSchema)]
#[serde(rename_all = "camelCase", default)]
struct AccessibilityOverrides {
    accessors: Option<AccessibilityLevel>,
    constructors: Option<AccessibilityLevel>,
    methods: Option<AccessibilityLevel>,
    parameter_properties: Option<AccessibilityLevel>,
    properties: Option<AccessibilityLevel>,
}

Implement Rule::from_configuration to parse the JSON options (array with one object element), resolving each override against the base accessibility.

3. Implement Rule::run

Match on three AstKind variants:

• AstKind::MethodDefinition(method): Skip if key.is_private_identifier(). Determine the effective check level based on method.kind (Constructor -> ctorCheck, Get/Set -> accessorCheck, Method -> methodCheck). Skip if the method name is in ignoredMethodNames. Then:

  • "no-public" + accessibility == Some(Public) -> report unwantedPublicAccessibility with a fix removing public
  • "explicit" + accessibility.is_none() -> report missingAccessibility with suggestions to add each modifier

• AstKind::PropertyDefinition(prop): Skip if key.is_private_identifier(). Use propCheck. Same check/report pattern.

• AstKind::AccessorProperty(prop): Skip if key.is_private_identifier(). Use propCheck (following the upstream which uses propCheck for all property-like members). Same check/report pattern.

For parameter properties, match on AstKind::FormalParameter(param) when param.has_modifier(). Use paramPropCheck. The "no-public" case only applies when accessibility == Some(Public) AND readonly == true (matches upstream behavior). The "explicit" case reports when accessibility.is_none() (the param has readonly/override but no explicit visibility keyword).

4. Diagnostics

Define helper functions:

fn missing_accessibility(span, member_type, name) -> OxcDiagnostic
fn unwanted_public_accessibility(span, member_type, name) -> OxcDiagnostic

5. Fixes and suggestions

• Removing public (no-public violations): Use fixer.delete_range(...) targeting the public keyword span. The span can be computed as Span::new(node.span.start, <first-non-public-token-start>) -- but we need to be careful about decorators. A simpler approach: search for "public " in the source text within the member's span and remove it.
• Adding modifiers (explicit violations): Use ctx.diagnostic_with_suggestion(...) with suggestions for public , private , and protected . Insert text before the member's key (or before the first token after decorators).

6. Tests

Add comprehensive test cases following the upstream test file patterns, using Tester:

• Default { accessibility: "explicit" } -- missing modifiers on methods, properties, accessors, constructors, parameter properties
• { accessibility: "no-public" } -- unwanted public on each member type
• { accessibility: "off" } -- no reports
• Override combinations (e.g. { accessibility: "no-public", overrides: { properties: "explicit" } })
• ignoredMethodNames option
• Private identifier (#foo) members are always skipped
• Fix tests for public removal, suggestion tests for adding modifiers

7. Finalize

• Run just fmt
• Run cargo test -p oxc_linter to verify tests pass
• Run cargo insta review if needed to accept snapshots
• Run just ready for final checks