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

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

#[derive(Debug, Error, Diagnostic)]
#[error("deepscan(number-arg-out-of-range): Radix or precision arguments of number-related functions should not exceed the limit")]
#[diagnostic(
    severity(warning),
    help("The first argument of 'Number.prototype.{0}' should be a number between {1} and {2}")
)]
struct NumberArgOutOfRangeDiagnostic(CompactStr, usize, usize, #[label] pub Span);

/// `https://deepscan.io/docs/rules/number-arg-out-of-range`
#[derive(Debug, Default, Clone)]
pub struct NumberArgOutOfRange;

declare_oxc_lint!(
    /// ### What it does
    ///
    /// Checks whether the radix or precision arguments of number-related functions exceeds the limit.
    ///
    /// ### Example
    /// ```javascript
    /// var x = 42;
    /// var s_radix_64 = x.toString(64);
    /// var s = x.toString(1);
    /// ```
    NumberArgOutOfRange,
    correctne
    
    fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
        let AstKind::CallExpression(expr) = node.kind() else {
            return;
        };

        if let Some(member) = expr.callee.get_member_expr() {
            if let Some(Argument::Expression(Expression::NumericLiteral(literal))) =
                expr.arguments.first()
            {
                let value = literal.value;
                match member.static_property_name() {
                    Some(name @ "toString") => {
                        if !(2.0_f64..=36.0_f64).contains(&value) {
                            let name = CompactStr::from(name);
                            ctx.diagnostic(NumberArgOutOfRangeDiagnostic(name, 2, 36, expr.span));
                        }
                    }
                    Some(name @ ("toFixed" | "toExponential")) => {
                        if !(0.0_f64..=20.0_f64).contains(&value) {
                            let name = CompactStr::from(name);
                            ctx.diagnostic(NumberArgOutOfRangeDiagnostic(name, 0, 20, expr.span));
                        }
                    }
                    Some(name @ "toPrecision") => {
                        if !(1.0_f64..=21.0_f64).contains(&value) {
                            let name = CompactStr::from(name);
                            ctx.diagnostic(NumberArgOutOfRangeDiagnostic(name, 1, 21, expr.span));
                        }
                    }
                    _ => {}
                }
            }
        }
    }