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: lib.rs
    path of file: ./repos/kcl/kclvm/lexer/src
    
    the code of the file until where you have to start completion: //! Low-level token stream lexer.
//!
//! The purpose of `kclvm_lexer` is similar to [`rustc_lexer`] crate,
//! which separates out pure lexing and language-specific designs.
//!
//! The difference with [`rustc_lexer`] is that here we want to define
//! a more general and wider range of tokens used by more languages.
//!
//! A language-specific lexer is needed to convert the basic token stream
//! into wide tokens consumed by the parser.
//!
//! The purpose of the lexer is to convert raw sources into a labeled sequence
//! of well-known token t
    
    fn token(&mut self) -> Token {
        let char = self.bump().unwrap_or(EOF_CHAR);

        let token_kind = match char {
            // Comment or block comment, or a simple token
            c if self.try_comment_magic(c) => self.eat_comment(),

            // Whitespace sequence.
            c if is_whitespace(c) => Whitespace,

            // Various of string. E.g., quoted string, raw string.
            c if self.try_string_magic(c) => self.eat_string(c),

            // Identifier (this should be checked after other variant that can
            // start as identifier).
            c if self.try_ident_magic(c) => self.eat_ident(),

            // Numeric literal.
            c @ '0'..='9' => {
                let kind = self.number(c);
                let suffix_start = self.len_consumed();
                self.eat_lit_suffix(); // In case we have some suffix

                TokenKind::Literal { kind, suffix_start }
            }

            // '\r' will be considered as a 'WhiteSpace'.
            '\u{0009}' => Tab,
            '\u{0020}' => Space,
            '\u{000A}' => Newline,

            ';' => Semi,
            ',' => Comma,
            '.' => match (self.peek(), self.peek1th()) {
                ('.', '.') => {
                    self.bump();
                    self.bump();
                    DotDotDot
                }
                _ => Dot,
            },
            '(' => OpenParen,
            ')' => CloseParen,
            '{' => OpenBrace,
            '}' => CloseBrace,
            '[' => OpenBracket,
            ']' => CloseBracket,
            '@' => At,
            '#' => Pound,
            '~' => Tilde,
            '?' => Question,
            ':' => Colon,
            '$' => Dollar,
            '=' => match self.peek() {
                '=' => {
                    self.bump();
                    EqEq
                }
                _ => Eq,
            },
            '!' => match self.peek() {
                '=' => {
                    self.bump();
                    BangEq
                }
                _ => Bang,
            },
            '<' => match self.peek() {
                '=' => {
                    self.bump();
                    LtEq
                }
                '<' => {
                    self.bump();
                    match self.peek() {
                        '=' => {
                            self.bump();
                            LtLtEq
                        }
                        _ => LtLt,
                    }
                }
                _ => Lt,
            },
            '>' => match self.peek() {
                '=' => {
                    self.bump();
                    GtEq
                }
                '>' => {
                    self.bump();
                    match self.peek() {
                        '=' => {
                            self.bump();
                            GtGtEq
                        }
                        _ => GtGt,
                    }
                }
                _ => Gt,
            },
            '-' => match self.peek() {
                '=' => {
                    self.bump();
                    MinusEq
                }
                _ => Minus,
            },
            '&' => match self.peek() {
                '=' => {
                    self.bump();
                    AndEq
                }
                _ => And,
            },
            '|' => match self.peek() {
                '=' => {
                    self.bump();
                    OrEq
                }
                _ => Or,
            },
            '+' => match self.peek() {
                '=' => {
                    self.bump();
                    PlusEq
                }
                _ => Plus,
            },
            '*' => match self.peek() {
                '*' => {
                    self.bump();
                    match self.peek() {
                        '=' => {
                            self.bump();
                            StarStarEq
                        }
                        _ => StarStar,
                    }
                }
                '=' => {
                    self.bump();
                    StarEq
                }
                _ => Star,
            },
            '/' => match self.peek() {
                '/' => {
                    self.bump();
                    match self.peek() {
                        '=' => {
                            self.bump();
                            SlashSlashEq
                        }
                        _ => SlashSlash,
                    }
                }
                '=' => {
                    self.bump();
                    SlashEq
                }
                _ => Slash,
            },
            '^' => match self.peek() {
                '=' => {
                    self.bump();
                    CaretEq
                }
                _ => Caret,
            },
            '%' => match self.peek() {
                '=' => {
                    self.bump();
                    PercentEq
                }
                _ => Percent,
            },
            '\\' => match self.peek() {
                '\n' => {
                    self.bump();
                    LineContinue
                }
                EOF_CHAR => LineContinue,
                _ => InvalidLineContinue,
            },
            // Identifier starting with an emoji. Only lexed for graceful error recovery.
            c if !c.is_ascii() && unic_emoji_char::is_emoji(c) => {
                self.fake_ident_or_unknown_prefix()
            }
            _ => Unknown,
        };
        Token::new(token_kind, self.len_consumed())
    }