You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: no_redeclare.rs
    path of file: ./repos/oxc/crates/oxc_linter/src/rules/eslint
    
    the code of the file until where you have to start completion: use oxc_ast::{
    ast::{BindingIdentifier, BindingPatternKind},
    AstKind,
};
use oxc_diagnostics::{
    miette::{self, Diagnostic},
    thiserror::{self, Error},
};
use oxc_macros::declare_oxc_lint;
use oxc_span::{CompactStr, Span};

use crate::{context::LintContext, rule::Rule};

#[derive(Debug, Error, Diagnostic)]
#[error("eslint(no-redeclare): '{0}' is already defined.")]
#[diagnostic(severity(warning))]
struct NoRedeclareDiagnostic(
    CompactStr,
    #[label("'{0}' is already defined.")] pub Span,
    #[label("It can not be redeclare here.")] pub Span,
);

#[derive(Debug, Error, Diagnostic)]
#[error("eslint(no-redeclare): '{0}' is already defined as a built-in global variable.")]
#[diagnostic(severity(warning))]
struct NoRedeclareAsBuiltiInDiagnostic(
    CompactStr,
    #[label("'{0}' is already defined as a built-in global variable.")] pub Span,
);

#[derive(Debug, Error, Diagnostic)]
#[error("eslint(no-redeclare): '{0}' is already defined by a variable declaration.")]
#[diagnostic(severity(warning))]
struct NoRedeclareBySyntaxDiagnostic(
    CompactStr,
    #[label("'{0}' is already defined by a variable declaration.")] pub Span,
    #[label("It cannot be redeclared here.")] pub Span,
);

#[derive(Debug, Default, Clone)]
pub str
    
    fn run_once(&self, ctx: &LintContext) {
        let symbol_table = ctx.semantic().symbols();

        for symbol_id in ctx.symbols().iter() {
            let decl = symbol_table.get_declaration(symbol_id);
            let symbol_name = symbol_table.get_name(symbol_id);
            match ctx.nodes().kind(decl) {
                AstKind::VariableDeclarator(var) => {
                    if let BindingPatternKind::BindingIdentifier(ident) = &var.id.kind {
                        if symbol_name == ident.name.as_str() {
                            for span in ctx.symbols().get_redeclare_variables(symbol_id) {
                                self.report_diagnostic(ctx, *span, ident);
                            }
                        }
                    }
                }
                AstKind::FormalParameter(param) => {
                    if let BindingPatternKind::BindingIdentifier(ident) = &param.pattern.kind {
                        if symbol_name == ident.name.as_str() {
                            for span in ctx.symbols().get_redeclare_variables(symbol_id) {
                                self.report_diagnostic(ctx, *span, ident);
                            }
                        }
                    }
                }
                _ => {}
            }
        }
    }