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_invalid_remove_event_listener.rs
    path of file: ./repos/oxc/crates/oxc_linter/src/rules/unicorn
    
    the code of the file until where you have to start completion: use oxc_ast::ast::Expression;
use oxc_ast::{
    ast::{Argument, MemberExpression},
    AstKind,
};
use oxc_diagnostics::{
    miette::{self, Diagnostic},
    thiserror::Error,
};
use oxc_macros::declare_oxc_lint;
use oxc_span::{GetSpan, Span};

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

#[derive(Debug, Error, Diagnostic)]
#[error(
    "eslint-plugin-unicorn(no-invalid-remove-event-listener): Invalid `removeEventListener` call."
)]
#[diagnostic(severity(warning), help("The listener argument should be a function reference."))]
struct NoInvalidRemoveEventListenerDiagnostic(
    #[label("`removeEventListener` called here.")] pub Span,
    #[label("Invalid argument here")] pub Span,
);

#[derive(Debug, Default, Clone)]
pub struct NoInvalidRemoveEventListener;

declare_oxc_lint!(
    /// ### What it does
    ///
    /// It warns when you use a non-function value as the second argument of `removeEventListener`.
    ///
    /// ### Why is this bad?
    ///
    /// The [`removeEventListener`](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/removeEventListener) function must be called with a reference to the same function that was passed to [`addEventListener`](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener). Calling `removeEventListener` with an inline function or the result of an inline `.bind()` call is indicative of an error, and won't actually remove the listener.
    ///
    /// ### Example
    /// ```javascript
    /// // Bad
    /// el.removeEventListener('c
    
    fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
        let AstKind::CallExpression(call_expr) = node.kind() else { return };

        if call_expr.optional {
            return;
        }

        let Some(member_expr) = call_expr.callee.get_member_expr() else { return };

        let remove_event_listener_ident_span = match member_expr {
            MemberExpression::StaticMemberExpression(v) => {
                if v.property.name != "removeEventListener" {
                    return;
                }
                v.property.span
            }
            _ => return,
        };

        if member_expr.optional() {
            return;
        }

        if matches!(call_expr.arguments.first(), Some(Argument::SpreadElement(_))) {
            return;
        }

        let Some(Argument::Expression(listener)) = call_expr.arguments.get(1) else { return };

        if !matches!(
            listener,
            Expression::FunctionExpression(_)
                | Expression::ArrowFunctionExpression(_)
                | Expression::CallExpression(_)
        ) {
            return;
        }

        if let Expression::CallExpression(call_expr) = listener {
            match call_expr.callee.get_member_expr() {
                Some(MemberExpression::StaticMemberExpression(v)) => {
                    if v.property.name != "bind" {
                        return;
                    }
                }
                _ => {
                    return;
                }
            }
        }

        let listener_span = listener.span();
        let listener_span = if listener_span.size() > 20 {
            match listener {
                Expression::FunctionExpression(func_expr) => {
                    Span::new(func_expr.span.start, func_expr.params.span.end)
                }
                Expression::ArrowFunctionExpression(arrow_expr) => {
                    Span::new(arrow_expr.span.start, arrow_expr.body.span.start)
                }
                Expression::CallExpression(_) => listener_span,
                _ => unreachable!(),
            }
        } else {
            listener_span
        };

        ctx.diagnostic(NoInvalidRemoveEventListenerDiagnostic(
            remove_event_listener_ident_span,
            listener_span,
        ));
    }