oxc_linter

[dependencies]
oxc_linter = "1.51.0"
oxc_parser = "0.116.0"
oxc_semantic = "0.116.0"
oxc_allocator = "0.116.0"
oxc_span = "0.116.0"

use oxc_allocator::Allocator;
use oxc_linter::{Linter, LintOptions};
use oxc_parser::Parser;
use oxc_semantic::SemanticBuilder;
use oxc_span::SourceType;
use std::path::Path;

let allocator = Allocator::default();
let source = "debugger;";
let source_type = SourceType::default();
let path = Path::new("test.js");

// Parse and build semantic model
let parsed = Parser::new(&allocator, source, source_type).parse();
let semantic = SemanticBuilder::new()
    .with_check_syntax_error(true)
    .build(&parsed.program)
    .semantic;

// Create linter with default rules
let linter = Linter::default();

// Run linter
let messages = linter.run(path, vec![semantic], &allocator);

for message in messages {
    println!("{}:{}: {}", 
             message.span.start,
             message.span.end, 
             message.error);
}

impl Linter {
    pub fn new(
        options: LintOptions,
        config: ConfigStore,
        external_linter: Option<ExternalLinter>
    ) -> Self;
    
    pub fn default() -> Self;  // Uses default configuration
}

impl Linter {
    // Run linter on a file
    pub fn run<'a>(
        &self,
        path: &Path,
        context_sub_hosts: Vec<ContextSubHost<'a>>,
        allocator: &'a Allocator
    ) -> Vec<Message>;
    
    // Configure auto-fixing
    pub fn with_fix(mut self, kind: FixKind) -> Self;
    
    // Get number of enabled rules
    pub fn number_of_rules(&self, type_aware: bool) -> Option<usize>;
}

pub struct LintOptions {
    pub fix: FixKind,
    pub report_unused_directive: Option<AllowWarnDeny>,
}

pub struct Message {
    pub error: OxcDiagnostic,
    pub fixes: PossibleFixes,
}

pub enum FixKind {
    None,           // No fixes
    Fix,            // Only safe fixes
    Suggestion,     // Only suggestions  
    All,            // Both safe fixes and suggestions
}

use oxc_linter::{ConfigStore, ConfigStoreBuilder, LintOptions, Linter};

// Build configuration from .oxlintrc.json
let config = ConfigStoreBuilder::new()
    .with_config_file(Path::new(".oxlintrc.json"))
    .build()?;

let linter = Linter::new(
    LintOptions::default(),
    config,
    None  // No external linter
);

use oxc_linter::{
    AllowWarnDeny, LintFilter, LintFilterKind,
    ConfigStoreBuilder
};

let config = ConfigStoreBuilder::new()
    // Enable specific rules
    .with_filters(vec![
        LintFilter::new(AllowWarnDeny::Deny, "no-debugger"),
        LintFilter::new(AllowWarnDeny::Warn, "no-console"),
    ])
    .build()?;

use oxc_allocator::Allocator;
use oxc_ast::AstKind;
use oxc_diagnostics::OxcDiagnostic;
use oxc_parser::Parser;
use oxc_semantic::SemanticBuilder;
use oxc_span::{SourceType, Span};

fn check_debugger(source: &str, source_type: SourceType) -> Vec<OxcDiagnostic> {
    let allocator = Allocator::default();
    let parsed = Parser::new(&allocator, source, source_type).parse();
    let semantic = SemanticBuilder::new().build(&parsed.program).semantic;
    
    let mut errors = vec![];
    
    // Check for debugger statements
    for node in semantic.nodes() {
        if let AstKind::DebuggerStatement(stmt) = node.kind() {
            errors.push(
                OxcDiagnostic::error("`debugger` statement is not allowed")
                    .with_label(stmt.span)
            );
        }
    }
    
    errors
}

let errors = check_debugger("debugger;", SourceType::default());
assert_eq!(errors.len(), 1);

use oxc_linter::{FixKind, Linter, LintOptions};

let linter = Linter::default()
    .with_fix(FixKind::All);  // Apply all available fixes

let messages = linter.run(path, vec![semantic], &allocator);

// Collect and apply fixes
for message in messages {
    if let Some(fix) = message.fixes.first() {
        println!("Fix available: {:?}", fix);
    }
}

use oxc_allocator::Allocator;
use oxc_ast::AstKind;
use oxc_diagnostics::OxcDiagnostic;
use oxc_parser::Parser;
use oxc_semantic::SemanticBuilder;

fn check_empty_patterns(source: &str) -> Vec<OxcDiagnostic> {
    let allocator = Allocator::default();
    let parsed = Parser::new(&allocator, source, SourceType::default()).parse();
    let semantic = SemanticBuilder::new().build(&parsed.program).semantic;
    
    let mut errors = vec![];
    
    for node in semantic.nodes() {
        match node.kind() {
            AstKind::ArrayPattern(array) if array.elements.is_empty() => {
                errors.push(
                    OxcDiagnostic::error("Empty array pattern")
                        .with_label(array.span)
                );
            }
            AstKind::ObjectPattern(object) if object.properties.is_empty() => {
                errors.push(
                    OxcDiagnostic::error("Empty object pattern")
                        .with_label(object.span)
                );
            }
            _ => {}
        }
    }
    
    errors
}

use oxc_linter::{AllowWarnDeny, LintFilter};

let filters = vec![
    // Enable all rules from a category
    LintFilter::new(AllowWarnDeny::Deny, "react"),
    
    // Disable specific rule
    LintFilter::new(AllowWarnDeny::Allow, "react/no-children-prop"),
    
    // Enable specific rule
    LintFilter::new(AllowWarnDeny::Warn, "no-console"),
];

let config = ConfigStoreBuilder::new()
    .with_filters(filters)
    .build()?;

{
  "rules": {
    "no-debugger": "error",
    "no-console": "warn",
    "eqeqeq": ["error", "always"],
    "react/jsx-key": "error"
  },
  "env": {
    "browser": true,
    "node": true
  }
}

// Disable next line
// eslint-disable-next-line no-debugger
debugger;

// Disable entire file
/* eslint-disable no-console */
console.log('Hello');

// Disable multiple rules
// eslint-disable-next-line no-debugger, no-console