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: tags.rs
    path of file: ./repos/rust-analyzer/crates/ide/src/syntax_highlighting
    
    the code of the file until where you have to start completion: //! Defines token tags we use for syntax highlighting.
//! A tag is not unlike a CSS class.

use std::{
    fmt::{self, Write},
    ops,
};

use ide_db::SymbolKind;

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct Highlight {
    pub tag: HlTag,
    pub mods: HlMods,
}

#[derive(Default, Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct HlMods(u32);

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub enum HlTag {
    Symbol(SymbolKind),

    AttributeBracket,
    BoolLiteral,
    BuiltinType,
    ByteLiteral,
    CharLiteral,
    Comment,
    EscapeSequence,
    FormatSpecifier,
    InvalidEscapeSequence,
    Keyword,
    NumericLiteral,
    Operator(HlOperator),
    Punctuation(HlPunct),
    StringLiteral,
    UnresolvedReference,

    // For things which don't have a specific highlight.
    None,
}

// Don't forget to adjust the feature description in crates/ide/src/syntax_highlighting.rs.
// And make sure to use the lsp strings used when converting to the protocol in crates\rust-analyzer\src\semantic_tokens.rs, not the names of the variants here.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[repr(u8)]
pub enum HlMod {
    /// Used for items in traits and impls.
    Associated = 0,
    /// Used with keywords like `async` and `await`.
    Async,
    /// Used to differentiate individual elements within attribute calls.
    Attribute,
    /// Callable item or value.
    Callable,
    /// Value that is being consumed in a function call
    Consuming,
    /// Used with keywords like `if` and `break`.
    ControlFlow,
    /// Used for crate names, like `serde`.
    CrateRoot,
    /// Used for items from built-in crates (std, core, alloc, test and proc_macro).
    DefaultLibrary,
    /// `foo` in `fn foo(x: i32)` is a definition, `foo` in `foo(90 + 2)` is
    /// not.
    Definition,
    /// Doc-strings like this one.
    Documentation,
    /// Highlighting injection like rust code in doc strings or ra_fixture.
    Injected,
    /// Used for intra doc links in doc injection.
    IntraDocLink,
    /// Used for items from other crates.
    Library,
    /// Used to differentiate individual elements within macro calls.
    Macro,
    ProcMacro,
    /// Mutable binding.
    Mutable,
    /// Used for public items.
    Public,
    /// Immutable reference.
    Reference,
    /// Used for associated functions.
    Static,
    /// Used for items in traits and trait impls.
    Trait,
    // Keep this last!
    /// Used for unsafe functions, unsafe traits, mutable statics, union accesses and unsafe operations.
    Unsafe,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub enum HlPunct {
    /// []
    Bracket,
    /// {}
    Brace,
    /// ()
   
    
    fn as_str(self) -> &'static str {
        match self {
            HlTag::Symbol(symbol) => match symbol {
                SymbolKind::Attribute => "attribute",
                SymbolKind::BuiltinAttr => "builtin_attr",
                SymbolKind::Const => "constant",
                SymbolKind::ConstParam => "const_param",
                SymbolKind::Derive => "derive",
                SymbolKind::DeriveHelper => "derive_helper",
                SymbolKind::Enum => "enum",
                SymbolKind::Field => "field",
                SymbolKind::Function => "function",
                SymbolKind::Impl => "self_type",
                SymbolKind::Label => "label",
                SymbolKind::LifetimeParam => "lifetime",
                SymbolKind::Local => "variable",
                SymbolKind::Macro => "macro",
                SymbolKind::ProcMacro => "proc_macro",
                SymbolKind::Module => "module",
                SymbolKind::SelfParam => "self_keyword",
                SymbolKind::SelfType => "self_type_keyword",
                SymbolKind::Static => "static",
                SymbolKind::Struct => "struct",
                SymbolKind::ToolModule => "tool_module",
                SymbolKind::Trait => "trait",
                SymbolKind::TraitAlias => "trait_alias",
                SymbolKind::TypeAlias => "type_alias",
                SymbolKind::TypeParam => "type_param",
                SymbolKind::Union => "union",
                SymbolKind::ValueParam => "value_param",
                SymbolKind::Variant => "enum_variant",
            },
            HlTag::AttributeBracket => "attribute_bracket",
            HlTag::BoolLiteral => "bool_literal",
            HlTag::BuiltinType => "builtin_type",
            HlTag::ByteLiteral => "byte_literal",
            HlTag::CharLiteral => "char_literal",
            HlTag::Comment => "comment",
            HlTag::EscapeSequence => "escape_sequence",
            HlTag::InvalidEscapeSequence => "invalid_escape_sequence",
            HlTag::FormatSpecifier => "format_specifier",
            HlTag::Keyword => "keyword",
            HlTag::Punctuation(punct) => match punct {
                HlPunct::Bracket => "bracket",
                HlPunct::Brace => "brace",
                HlPunct::Parenthesis => "parenthesis",
                HlPunct::Angle => "angle",
                HlPunct::Comma => "comma",
                HlPunct::Dot => "dot",
                HlPunct::Colon => "colon",
                HlPunct::Semi => "semicolon",
                HlPunct::MacroBang => "macro_bang",
                HlPunct::Other => "punctuation",
            },
            HlTag::NumericLiteral => "numeric_literal",
            HlTag::Operator(op) => match op {
                HlOperator::Bitwise => "bitwise",
                HlOperator::Arithmetic => "arithmetic",
                HlOperator::Logical => "logical",
                HlOperator::Comparison => "comparison",
                HlOperator::Other => "operator",
            },
            HlTag::StringLiteral => "string_literal",
            HlTag::UnresolvedReference => "unresolved_reference",
            HlTag::None => "none",
        }
    }