editors/code/rust.tmGrammar.json

   1 {
   2         "name": "Rust",
   3         "scopeName": "source.rust",
   4         "patterns": [
   5                 {
   6                         "comment": "Implementation",
   7                         "begin": "\\b(impl)\\b",
   8                         "end": "\\{",
   9                         "beginCaptures": {
  10                                 "1": {
  11                                         "name": "storage.type.rust"
  12                                 }
  13                         },
  14                         "patterns": [
  15                                 {
  16                                         "include": "#block_comment"
  17                                 },
  18                                 {
  19                                         "include": "#line_comment"
  20                                 },
  21                                 {
  22                                         "include": "#sigils"
  23                                 },
  24                                 {
  25                                         "include": "#mut"
  26                                 },
  27                                 {
  28                                         "include": "#dyn"
  29                                 },
  30                                 {
  31                                         "include": "#ref_lifetime"
  32                                 },
  33                                 {
  34                                         "include": "#core_types"
  35                                 },
  36                                 {
  37                                         "include": "#core_marker"
  38                                 },
  39                                 {
  40                                         "include": "#core_traits"
  41                                 },
  42                                 {
  43                                         "include": "#std_types"
  44                                 },
  45                                 {
  46                                         "include": "#std_traits"
  47                                 },
  48                                 {
  49                                         "include": "#type_params"
  50                                 },
  51                                 {
  52                                         "include": "#where"
  53                                 },
  54                                 {
  55                                         "name": "storage.type.rust",
  56                                         "match": "\\bfor\\b"
  57                                 },
  58                                 {
  59                                         "include": "#type"
  60                                 }
  61                         ]
  62                 },
  63                 {
  64                         "include": "#block_doc_comment"
  65                 },
  66                 {
  67                         "include": "#block_comment"
  68                 },
  69                 {
  70                         "include": "#line_doc_comment"
  71                 },
  72                 {
  73                         "include": "#line_comment"
  74                 },
  75                 {
  76                         "comment": "Attribute",
  77                         "name": "meta.attribute.rust",
  78                         "begin": "#\\!?\\[",
  79                         "end": "\\]",
  80                         "patterns": [
  81                                 {
  82                                         "include": "#string_literal"
  83                                 },
  84                                 {
  85                                         "include": "#block_doc_comment"
  86                                 },
  87                                 {
  88                                         "include": "#block_comment"
  89                                 },
  90                                 {
  91                                         "include": "#line_doc_comment"
  92                                 },
  93                                 {
  94                                         "include": "#line_comment"
  95                                 }
  96                         ]
  97                 },
  98                 {
  99                         "comment": "Single-quote string literal (character)",
 100                         "name": "string.quoted.single.rust",
 101                         "match": "b?'([^'\\\\]|\\\\(x[0-9A-Fa-f]{2}|[0-2][0-7]{0,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.))'"
 102                 },
 103                 {
 104                         "include": "#string_literal"
 105                 },
 106                 {
 107                         "include": "#raw_string_literal"
 108                 },
 109                 {
 110                         "comment": "Floating point literal (fraction)",
 111                         "name": "constant.numeric.float.rust",
 112                         "match": "\\b[0-9][0-9_]*\\.[0-9][0-9_]*([eE][+-]?[0-9_]+)?(f32|f64)?\\b"
 113                 },
 114                 {
 115                         "comment": "Floating point literal (exponent)",
 116                         "name": "constant.numeric.float.rust",
 117                         "match": "\\b[0-9][0-9_]*(\\.[0-9][0-9_]*)?[eE][+-]?[0-9_]+(f32|f64)?\\b"
 118                 },
 119                 {
 120                         "comment": "Floating point literal (typed)",
 121                         "name": "constant.numeric.float.rust",
 122                         "match": "\\b[0-9][0-9_]*(\\.[0-9][0-9_]*)?([eE][+-]?[0-9_]+)?(f32|f64)\\b"
 123                 },
 124                 {
 125                         "comment": "Integer literal (decimal)",
 126                         "name": "constant.numeric.integer.decimal.rust",
 127                         "match": "\\b[0-9][0-9_]*([ui](8|16|32|64|128|s|size))?\\b"
 128                 },
 129                 {
 130                         "comment": "Integer literal (hexadecimal)",
 131                         "name": "constant.numeric.integer.hexadecimal.rust",
 132                         "match": "\\b0x[a-fA-F0-9_]+([ui](8|16|32|64|128|s|size))?\\b"
 133                 },
 134                 {
 135                         "comment": "Integer literal (octal)",
 136                         "name": "constant.numeric.integer.octal.rust",
 137                         "match": "\\b0o[0-7_]+([ui](8|16|32|64|128|s|size))?\\b"
 138                 },
 139                 {
 140                         "comment": "Integer literal (binary)",
 141                         "name": "constant.numeric.integer.binary.rust",
 142                         "match": "\\b0b[01_]+([ui](8|16|32|64|128|s|size))?\\b"
 143                 },
 144                 {
 145                         "comment": "Static storage modifier",
 146                         "name": "storage.modifier.static.rust",
 147                         "match": "\\bstatic\\b"
 148                 },
 149                 {
 150                         "comment": "Boolean constant",
 151                         "name": "constant.language.boolean.rust",
 152                         "match": "\\b(true|false)\\b"
 153                 },
 154                 {
 155                         "comment": "Control keyword",
 156                         "name": "keyword.control.rust",
 157                         "match": "\\b(async|await|break|continue|else|if|in|for|loop|match|return|try|while)\\b"
 158                 },
 159                 {
 160                         "comment": "Keyword",
 161                         "name": "keyword.other.rust",
 162                         "match": "\\b(crate|extern|mod|let|ref|use|super|move|as)\\b"
 163                 },
 164                 {
 165                         "comment": "Reserved keyword",
 166                         "name": "invalid.deprecated.rust",
 167                         "match": "\\b(abstract|alignof|become|do|final|macro|offsetof|override|priv|proc|pure|sizeof|typeof|virtual|yield)\\b"
 168                 },
 169                 {
 170                         "include": "#unsafe"
 171                 },
 172                 {
 173                         "include": "#sigils"
 174                 },
 175                 {
 176                         "include": "#self"
 177                 },
 178                 {
 179                         "include": "#mut"
 180                 },
 181                 {
 182                         "include": "#dyn"
 183                 },
 184                 {
 185                         "include": "#impl"
 186                 },
 187                 {
 188                         "include": "#box"
 189                 },
 190                 {
 191                         "include": "#lifetime"
 192                 },
 193                 {
 194                         "include": "#ref_lifetime"
 195                 },
 196                 {
 197                         "include": "#const"
 198                 },
 199                 {
 200                         "include": "#pub"
 201                 },
 202                 {
 203                         "comment": "Miscellaneous operator",
 204                         "name": "keyword.operator.misc.rust",
 205                         "match": "(=>|::)"
 206                 },
 207                 {
 208                         "comment": "Comparison operator",
 209                         "name": "keyword.operator.comparison.rust",
 210                         "match": "(&&|\\|\\||==|!=)"
 211                 },
 212                 {
 213                         "comment": "Assignment operator",
 214                         "name": "keyword.operator.assignment.rust",
 215                         "match": "(\\+=|-=|/=|\\*=|%=|\\^=|&=|\\|=|<<=|>>=|=)"
 216                 },
 217                 {
 218                         "comment": "Arithmetic operator",
 219                         "name": "keyword.operator.arithmetic.rust",
 220                         "match": "(!|\\+|-|/|\\*|%|\\^|&|\\||<<|>>)"
 221                 },
 222                 {
 223                         "comment": "Comparison operator (second group because of regex precedence)",
 224                         "name": "keyword.operator.comparison.rust",
 225                         "match": "(<=|>=|<|>)"
 226                 },
 227                 {
 228                         "include": "#core_types"
 229                 },
 230                 {
 231                         "include": "#core_vars"
 232                 },
 233                 {
 234                         "include": "#core_marker"
 235                 },
 236                 {
 237                         "include": "#core_traits"
 238                 },
 239                 {
 240                         "include": "#std_types"
 241                 },
 242                 {
 243                         "include": "#std_traits"
 244                 },
 245                 {
 246                         "comment": "Built-in macro",
 247                         "name": "support.function.builtin.rust",
 248                         "match": "\\b(macro_rules|compile_error|format_args|env|option_env|concat_idents|concat|line|column|file|stringify|include|include_str|include_bytes|module_path|cfg)!"
 249                 },
 250                 {
 251                         "comment": "Core macro",
 252                         "name": "support.function.core.rust",
 253                         "match": "\\b(panic|assert|assert_eq|assert_ne|debug_assert|debug_assert_eq|debug_assert_ne|try|write|writeln|unreachable|unimplemented)!"
 254                 },
 255                 {
 256                         "comment": "Standard library macro",
 257                         "name": "support.function.std.rust",
 258                         "match": "\\b(format|print|println|eprint|eprintln|select|vec)!"
 259                 },
 260                 {
 261                         "comment": "Logging macro",
 262                         "name": "support.function.log.rust",
 263                         "match": "\\b(log|error|warn|info|debug|trace|log_enabled)!"
 264                 },
 265                 {
 266                         "comment": "Invokation of a macro",
 267                         "match": "\\b([a-zA-Z_][a-zA-Z0-9_]*\\!)\\s*[({\\[]",
 268                         "captures": {
 269                                 "1": {
 270                                         "name": "entity.name.function.macro.rust"
 271                                 }
 272                         }
 273                 },
 274                 {
 275                         "comment": "Function call",
 276                         "match": "\\b([A-Za-z][A-Za-z0-9_]*|_[A-Za-z0-9_]+)\\s*\\(",
 277                         "captures": {
 278                                 "1": {
 279                                         "name": "entity.name.function.rust"
 280                                 }
 281                         }
 282                 },
 283                 {
 284                         "comment": "Function call with type parameters",
 285                         "begin": "\\b([A-Za-z][A-Za-z0-9_]*|_[A-Za-z0-9_]+)\\s*(::)(?=\\s*<.*>\\s*\\()",
 286                         "end": "\\(",
 287                         "captures": {
 288                                 "1": {
 289                                         "name": "entity.name.function.rust"
 290                                 },
 291                                 "2": {
 292                                         "name": "keyword.operator.misc.rust"
 293                                 }
 294                         },
 295                         "patterns": [
 296                                 {
 297                                         "include": "#type_params"
 298                                 }
 299                         ]
 300                 },
 301                 {
 302                         "comment": "Function definition",
 303                         "begin": "\\b(fn)\\s+([A-Za-z][A-Za-z0-9_]*|_[A-Za-z0-9_]+)",
 304                         "end": "[\\{;]",
 305                         "beginCaptures": {
 306                                 "1": {
 307                                         "name": "keyword.other.fn.rust"
 308                                 },
 309                                 "2": {
 310                                         "name": "entity.name.function.rust"
 311                                 }
 312                         },
 313                         "patterns": [
 314                                 {
 315                                         "include": "#block_comment"
 316                                 },
 317                                 {
 318                                         "include": "#line_comment"
 319                                 },
 320                                 {
 321                                         "include": "#sigils"
 322                                 },
 323                                 {
 324                                         "include": "#self"
 325                                 },
 326                                 {
 327                                         "include": "#mut"
 328                                 },
 329                                 {
 330                                         "include": "#dyn"
 331                                 },
 332                                 {
 333                                         "include": "#impl"
 334                                 },
 335                                 {
 336                                         "include": "#ref_lifetime"
 337                                 },
 338                                 {
 339                                         "include": "#core_types"
 340                                 },
 341                                 {
 342                                         "include": "#core_marker"
 343                                 },
 344                                 {
 345                                         "include": "#core_traits"
 346                                 },
 347                                 {
 348                                         "include": "#std_types"
 349                                 },
 350                                 {
 351                                         "include": "#std_traits"
 352                                 },
 353                                 {
 354                                         "include": "#type_params"
 355                                 },
 356                                 {
 357                                         "include": "#const"
 358                                 },
 359                                 {
 360                                         "include": "#where"
 361                                 },
 362                                 {
 363                                         "include": "#unsafe"
 364                                 },
 365                                 {
 366                                         "comment": "Function arguments",
 367                                         "match": "\bfn\b",
 368                                         "name": "keyword.other.fn.rust"
 369                                 }
 370                         ]
 371                 },
 372                 {
 373                         "comment": "Type declaration",
 374                         "begin": "\\b(enum|struct|trait|union)\\s+([a-zA-Z_][a-zA-Z0-9_]*)",
 375                         "end": "[\\{\\(;]",
 376                         "beginCaptures": {
 377                                 "1": {
 378                                         "name": "storage.type.rust"
 379                                 },
 380                                 "2": {
 381                                         "name": "entity.name.type.rust"
 382                                 }
 383                         },
 384                         "patterns": [
 385                                 {
 386                                         "include": "#block_comment"
 387                                 },
 388                                 {
 389                                         "include": "#line_comment"
 390                                 },
 391                                 {
 392                                         "include": "#core_traits"
 393                                 },
 394                                 {
 395                                         "include": "#std_traits"
 396                                 },
 397                                 {
 398                                         "include": "#type_params"
 399                                 },
 400                                 {
 401                                         "include": "#core_types"
 402                                 },
 403                                 {
 404                                         "include": "#pub"
 405                                 },
 406                                 {
 407                                         "include": "#where"
 408                                 }
 409                         ]
 410                 },
 411                 {
 412                         "comment": "Type alias",
 413                         "begin": "\\b(type)\\s+([a-zA-Z_][a-zA-Z0-9_]*)",
 414                         "end": ";",
 415                         "beginCaptures": {
 416                                 "1": {
 417                                         "name": "storage.type.rust"
 418                                 },
 419                                 "2": {
 420                                         "name": "entity.name.type.rust"
 421                                 }
 422                         },
 423                         "patterns": [
 424                                 {
 425                                         "include": "#block_comment"
 426                                 },
 427                                 {
 428                                         "include": "#line_comment"
 429                                 },
 430                                 {
 431                                         "include": "#sigils"
 432                                 },
 433                                 {
 434                                         "include": "#mut"
 435                                 },
 436                                 {
 437                                         "include": "#dyn"
 438                                 },
 439                                 {
 440                                         "include": "#impl"
 441                                 },
 442                                 {
 443                                         "include": "#lifetime"
 444                                 },
 445                                 {
 446                                         "include": "#ref_lifetime"
 447                                 },
 448                                 {
 449                                         "include": "#core_types"
 450                                 },
 451                                 {
 452                                         "include": "#core_marker"
 453                                 },
 454                                 {
 455                                         "include": "#core_traits"
 456                                 },
 457                                 {
 458                                         "include": "#std_types"
 459                                 },
 460                                 {
 461                                         "include": "#std_traits"
 462                                 },
 463                                 {
 464                                         "include": "#type_params"
 465                                 }
 466                         ]
 467                 }
 468         ],
 469         "repository": {
 470                 "block_doc_comment": {
 471                         "comment": "Block documentation comment",
 472                         "name": "comment.block.documentation.rust",
 473                         "begin": "/\\*[\\*!](?![\\*/])",
 474                         "end": "\\*/",
 475                         "patterns": [
 476                                 {
 477                                         "include": "#block_doc_comment"
 478                                 },
 479                                 {
 480                                         "include": "#block_comment"
 481                                 }
 482                         ]
 483                 },
 484                 "block_comment": {
 485                         "comment": "Block comment",
 486                         "name": "comment.block.rust",
 487                         "begin": "/\\*",
 488                         "end": "\\*/",
 489                         "patterns": [
 490                                 {
 491                                         "include": "#block_doc_comment"
 492                                 },
 493                                 {
 494                                         "include": "#block_comment"
 495                                 }
 496                         ]
 497                 },
 498                 "line_doc_comment": {
 499                         "comment": "Single-line documentation comment",
 500                         "name": "comment.line.documentation.rust",
 501                         "begin": "//[!/](?=[^/])",
 502                         "end": "$"
 503                 },
 504                 "line_comment": {
 505                         "comment": "Single-line comment",
 506                         "name": "comment.line.double-slash.rust",
 507                         "begin": "//",
 508                         "end": "$"
 509                 },
 510                 "escaped_character": {
 511                         "name": "constant.character.escape.rust",
 512                         "match": "\\\\(x[0-9A-Fa-f]{2}|[0-2][0-7]{0,2}|3[0-6][0-7]?|37[0-7]?|[4-7][0-7]?|.)"
 513                 },
 514                 "string_literal": {
 515                         "comment": "Double-quote string literal",
 516                         "name": "string.quoted.double.rust",
 517                         "begin": "b?\"",
 518                         "end": "\"",
 519                         "patterns": [
 520                                 {
 521                                         "include": "#escaped_character"
 522                                 }
 523                         ]
 524                 },
 525                 "raw_string_literal": {
 526                         "comment": "Raw double-quote string literal",
 527                         "name": "string.quoted.double.raw.rust",
 528                         "begin": "b?r(#*)\"",
 529                         "end": "\"\\1"
 530                 },
 531                 "sigils": {
 532                         "comment": "Sigil",
 533                         "name": "keyword.operator.sigil.rust",
 534                         "match": "[&*](?=[a-zA-Z0-9_\\(\\[\\|\\\"]+)"
 535                 },
 536                 "self": {
 537                         "comment": "Self variable",
 538                         "name": "variable.language.rust",
 539                         "match": "\\bself\\b"
 540                 },
 541                 "mut": {
 542                         "comment": "Mutable storage modifier",
 543                         "name": "storage.modifier.mut.rust",
 544                         "match": "\\bmut\\b"
 545                 },
 546                 "dyn": {
 547                         "comment": "Dynamic modifier",
 548                         "name": "storage.modifier.dyn.rust",
 549                         "match": "\\bdyn\\b"
 550                 },
 551                 "impl": {
 552                         "comment": "Existential type modifier",
 553                         "name": "storage.modifier.impl.rust",
 554                         "match": "\\bimpl\\b"
 555                 },
 556                 "box": {
 557                         "comment": "Box storage modifier",
 558                         "name": "storage.modifier.box.rust",
 559                         "match": "\\bbox\\b"
 560                 },
 561                 "const": {
 562                         "comment": "Const storage modifier",
 563                         "name": "storage.modifier.const.rust",
 564                         "match": "\\bconst\\b"
 565                 },
 566                 "pub": {
 567                         "comment": "Visibility modifier",
 568                         "name": "storage.modifier.visibility.rust",
 569                         "match": "\\bpub\\b"
 570                 },
 571                 "unsafe": {
 572                         "comment": "Unsafe code keyword",
 573                         "name": "keyword.other.unsafe.rust",
 574                         "match": "\\bunsafe\\b"
 575                 },
 576                 "where": {
 577                         "comment": "Generic where clause",
 578                         "name": "keyword.other.where.rust",
 579                         "match": "\\bwhere\\b"
 580                 },
 581                 "lifetime": {
 582                         "comment": "Named lifetime",
 583                         "name": "storage.modifier.lifetime.rust",
 584                         "match": "'([a-zA-Z_][a-zA-Z0-9_]*)\\b"
 585                 },
 586                 "ref_lifetime": {
 587                         "comment": "Reference with named lifetime",
 588                         "match": "(&)('[a-zA-Z_][a-zA-Z0-9_]*)\\b",
 589                         "captures": {
 590                                 "1": {
 591                                         "name": "keyword.operator.sigil.rust"
 592                                 },
 593                                 "2": {
 594                                         "name": "storage.modifier.lifetime.rust"
 595                                 }
 596                         }
 597                 },
 598                 "core_types": {
 599                         "comment": "Built-in/core type",
 600                         "name": "support.type.primitive.rust",
 601                         "match": "\\b(bool|char|usize|isize|u8|u16|u32|u64|u128|i8|i16|i32|i64|i128|f32|f64|str|Self)\\b"
 602                 },
 603                 "core_vars": {
 604                         "comment": "Core type variant",
 605                         "name": "support.constant.core.rust",
 606                         "match": "\\b(Some|None|Ok|Err)\\b"
 607                 },
 608                 "core_marker": {
 609                         "comment": "Core trait (marker)",
 610                         "name": "entity.name.type.marker.rust",
 611                         "match": "\\b(Copy|Send|Sized|Sync)\\b"
 612                 },
 613                 "core_traits": {
 614                         "comment": "Core trait",
 615                         "name": "entity.name.type.core.rust",
 616                         "match": "\\b(Drop|Fn|FnMut|FnOnce|Clone|PartialEq|PartialOrd|Eq|Ord|AsRef|AsMut|Into|From|Default|Iterator|Extend|IntoIterator|DoubleEndedIterator|ExactSizeIterator)\\b"
 617                 },
 618                 "std_types": {
 619                         "comment": "Standard library type",
 620                         "name": "entity.name.type.class.std.rust",
 621                         "match": "\\b(Box|String|Vec|Path|PathBuf|Option|Result)\\b"
 622                 },
 623                 "std_traits": {
 624                         "comment": "Standard library trait",
 625                         "name": "entity.name.type.std.rust",
 626                         "match": "\\b(ToOwned|ToString)\\b"
 627                 },
 628                 "type": {
 629                         "comment": "A type",
 630                         "name": "entity.name.type.rust",
 631                         "match": "\\b([A-Za-z][_A-Za-z0-9]*|_[_A-Za-z0-9]+)\\b"
 632                 },
 633                 "type_params": {
 634                         "comment": "Type parameters",
 635                         "name": "meta.type_params.rust",
 636                         "begin": "<(?![=<])",
 637                         "end": "(?<![-])>",
 638                         "patterns": [
 639                                 {
 640                                         "include": "#block_comment"
 641                                 },
 642                                 {
 643                                         "include": "#line_comment"
 644                                 },
 645                                 {
 646                                         "include": "#sigils"
 647                                 },
 648                                 {
 649                                         "include": "#mut"
 650                                 },
 651                                 {
 652                                         "include": "#dyn"
 653                                 },
 654                                 {
 655                                         "include": "#impl"
 656                                 },
 657                                 {
 658                                         "include": "#lifetime"
 659                                 },
 660                                 {
 661                                         "include": "#core_types"
 662                                 },
 663                                 {
 664                                         "include": "#core_marker"
 665                                 },
 666                                 {
 667                                         "include": "#core_traits"
 668                                 },
 669                                 {
 670                                         "include": "#std_types"
 671                                 },
 672                                 {
 673                                         "include": "#std_traits"
 674                                 },
 675                                 {
 676                                         "include": "#type_params"
 677                                 }
 678                         ]
 679                 }
 680         }
 681 }