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: mod.rs
    path of file: ./repos/tools/crates/rome_json_parser/src/lexer
    
    the code of the file until where you have to start completion: //! An extremely fast, lookup table based, JSON lexer which yields SyntaxKind tokens used by the rome-json parser.

#[rustfmt::skip]
mod tests;

use rome_js_unicode_table::{is_id_continue, is_id_start, lookup_byt
    
    fn lex_slash(&mut self) -> JsonSyntaxKind {
        let start = self.text_position();
        match self.peek_byte() {
            Some(b'*') => {
                // eat `/*`
                self.advance(2);

                let mut has_newline = false;

                while let Some(chr) = self.current_byte() {
                    match chr {
                        b'*' if self.peek_byte() == Some(b'/') => {
                            self.advance(2);

                            if !self.config.allow_comments {
                                self.diagnostics.push(ParseDiagnostic::new(
                                    "JSON standard does not allow comments.",
                                    start..self.text_position(),
                                ));
                            }

                            if has_newline {
                                return MULTILINE_COMMENT;
                            } else {
                                return COMMENT;
                            }
                        }
                        b'\n' | b'\r' => {
                            has_newline = true;
                            self.advance(1)
                        }
                        chr => self.advance_byte_or_char(chr),
                    }
                }

                let err =
                    ParseDiagnostic::new("Unterminated block comment", start..self.text_position())
                        .detail(
                            self.position..self.position + 1,
                            "... but the file ends here",
                        );

                self.diagnostics.push(err);

                if has_newline {
                    MULTILINE_COMMENT
                } else {
                    COMMENT
                }
            }
            Some(b'/') => {
                self.advance(2);

                while let Some(chr) = self.current_byte() {
                    match chr {
                        b'\n' | b'\r' => return COMMENT,
                        chr => self.advance_byte_or_char(chr),
                    }
                }

                if !self.config.allow_comments {
                    self.diagnostics.push(ParseDiagnostic::new(
                        "JSON standard does not allow comments.",
                        start..self.text_position(),
                    ));
                }

                COMMENT
            }
            _ => self.eat_unexpected_character(),
        }
    }