editors/code/package.json

   1 {
   2     "name": "rust-analyzer",
   3     "displayName": "rust-analyzer",
   4     "description": "Rust language support for Visual Studio Code",
   5     "private": true,
   6     "icon": "icon.png",
   7     "version": "0.5.0-dev",
   8     "releaseTag": null,
   9     "publisher": "rust-lang",
  10     "repository": {
  11         "url": "https://github.com/rust-lang/rust-analyzer.git",
  12         "type": "git"
  13     },
  14     "homepage": "https://rust-analyzer.github.io/",
  15     "license": "MIT OR Apache-2.0",
  16     "keywords": [
  17         "rust"
  18     ],
  19     "categories": [
  20         "Programming Languages"
  21     ],
  22     "engines": {
  23         "vscode": "^1.66.0"
  24     },
  25     "enabledApiProposals": [],
  26     "scripts": {
  27         "vscode:prepublish": "npm run build-base -- --minify",
  28         "package": "vsce package -o rust-analyzer.vsix",
  29         "build-base": "esbuild ./src/main.ts --bundle --outfile=out/main.js --external:vscode --format=cjs --platform=node --target=node16",
  30         "build": "npm run build-base -- --sourcemap",
  31         "watch": "npm run build-base -- --sourcemap --watch",
  32         "lint": "tsfmt --verify && eslint -c .eslintrc.js --ext ts ./src ./tests",
  33         "fix": " tsfmt -r       && eslint -c .eslintrc.js --ext ts ./src ./tests --fix",
  34         "pretest": "tsc && npm run build",
  35         "test": "cross-env TEST_VARIABLE=test node ./out/tests/runTests.js"
  36     },
  37     "dependencies": {
  38         "d3": "^7.3.0",
  39         "d3-graphviz": "^4.1.0",
  40         "vscode-languageclient": "8.0.0-next.14"
  41     },
  42     "devDependencies": {
  43         "@types/node": "~14.17.5",
  44         "@types/vscode": "~1.66.0",
  45         "@typescript-eslint/eslint-plugin": "^5.16.0",
  46         "@typescript-eslint/parser": "^5.16.0",
  47         "@vscode/test-electron": "^2.1.3",
  48         "cross-env": "^7.0.3",
  49         "esbuild": "^0.14.27",
  50         "eslint": "^8.11.0",
  51         "eslint-config-prettier": "^8.5.0",
  52         "prettier": "^2.6.2",
  53         "tslib": "^2.3.0",
  54         "typescript": "^4.6.3",
  55         "typescript-formatter": "^7.2.2",
  56         "vsce": "^2.7.0"
  57     },
  58     "activationEvents": [
  59         "onLanguage:rust",
  60         "onCommand:rust-analyzer.analyzerStatus",
  61         "onCommand:rust-analyzer.memoryUsage",
  62         "onCommand:rust-analyzer.reloadWorkspace",
  63         "workspaceContains:*/Cargo.toml",
  64         "workspaceContains:*/rust-project.json"
  65     ],
  66     "main": "./out/main",
  67     "contributes": {
  68         "taskDefinitions": [
  69             {
  70                 "type": "cargo",
  71                 "required": [
  72                     "command"
  73                 ],
  74                 "properties": {
  75                     "label": {
  76                         "type": "string"
  77                     },
  78                     "command": {
  79                         "type": "string"
  80                     },
  81                     "args": {
  82                         "type": "array",
  83                         "items": {
  84                             "type": "string"
  85                         }
  86                     },
  87                     "env": {
  88                         "type": "object",
  89                         "patternProperties": {
  90                             ".+": {
  91                                 "type": "string"
  92                             }
  93                         }
  94                     }
  95                 }
  96             }
  97         ],
  98         "commands": [
  99             {
 100                 "command": "rust-analyzer.syntaxTree",
 101                 "title": "Show Syntax Tree",
 102                 "category": "Rust Analyzer"
 103             },
 104             {
 105                 "command": "rust-analyzer.viewHir",
 106                 "title": "View Hir",
 107                 "category": "Rust Analyzer"
 108             },
 109             {
 110                 "command": "rust-analyzer.viewFileText",
 111                 "title": "View File Text (as seen by the server)",
 112                 "category": "Rust Analyzer"
 113             },
 114             {
 115                 "command": "rust-analyzer.viewItemTree",
 116                 "title": "Debug ItemTree",
 117                 "category": "Rust Analyzer"
 118             },
 119             {
 120                 "command": "rust-analyzer.viewCrateGraph",
 121                 "title": "View Crate Graph",
 122                 "category": "Rust Analyzer"
 123             },
 124             {
 125                 "command": "rust-analyzer.viewFullCrateGraph",
 126                 "title": "View Crate Graph (Full)",
 127                 "category": "Rust Analyzer"
 128             },
 129             {
 130                 "command": "rust-analyzer.expandMacro",
 131                 "title": "Expand macro recursively",
 132                 "category": "Rust Analyzer"
 133             },
 134             {
 135                 "command": "rust-analyzer.matchingBrace",
 136                 "title": "Find matching brace",
 137                 "category": "Rust Analyzer"
 138             },
 139             {
 140                 "command": "rust-analyzer.parentModule",
 141                 "title": "Locate parent module",
 142                 "category": "Rust Analyzer"
 143             },
 144             {
 145                 "command": "rust-analyzer.joinLines",
 146                 "title": "Join lines",
 147                 "category": "Rust Analyzer"
 148             },
 149             {
 150                 "command": "rust-analyzer.run",
 151                 "title": "Run",
 152                 "category": "Rust Analyzer"
 153             },
 154             {
 155                 "command": "rust-analyzer.copyRunCommandLine",
 156                 "title": "Copy Run Command Line",
 157                 "category": "Rust Analyzer"
 158             },
 159             {
 160                 "command": "rust-analyzer.debug",
 161                 "title": "Debug",
 162                 "category": "Rust Analyzer"
 163             },
 164             {
 165                 "command": "rust-analyzer.newDebugConfig",
 166                 "title": "Generate launch configuration",
 167                 "category": "Rust Analyzer"
 168             },
 169             {
 170                 "command": "rust-analyzer.analyzerStatus",
 171                 "title": "Status",
 172                 "category": "Rust Analyzer"
 173             },
 174             {
 175                 "command": "rust-analyzer.memoryUsage",
 176                 "title": "Memory Usage (Clears Database)",
 177                 "category": "Rust Analyzer"
 178             },
 179             {
 180                 "command": "rust-analyzer.shuffleCrateGraph",
 181                 "title": "Shuffle Crate Graph",
 182                 "category": "Rust Analyzer"
 183             },
 184             {
 185                 "command": "rust-analyzer.reloadWorkspace",
 186                 "title": "Reload workspace",
 187                 "category": "Rust Analyzer"
 188             },
 189             {
 190                 "command": "rust-analyzer.reload",
 191                 "title": "Restart server",
 192                 "category": "Rust Analyzer"
 193             },
 194             {
 195                 "command": "rust-analyzer.onEnter",
 196                 "title": "Enhanced enter key",
 197                 "category": "Rust Analyzer"
 198             },
 199             {
 200                 "command": "rust-analyzer.ssr",
 201                 "title": "Structural Search Replace",
 202                 "category": "Rust Analyzer"
 203             },
 204             {
 205                 "command": "rust-analyzer.serverVersion",
 206                 "title": "Show RA Version",
 207                 "category": "Rust Analyzer"
 208             },
 209             {
 210                 "command": "rust-analyzer.toggleInlayHints",
 211                 "title": "Toggle inlay hints",
 212                 "category": "Rust Analyzer"
 213             },
 214             {
 215                 "command": "rust-analyzer.openDocs",
 216                 "title": "Open docs under cursor",
 217                 "category": "Rust Analyzer"
 218             },
 219             {
 220                 "command": "rust-analyzer.openCargoToml",
 221                 "title": "Open Cargo.toml",
 222                 "category": "Rust Analyzer"
 223             },
 224             {
 225                 "command": "rust-analyzer.peekTests",
 226                 "title": "Peek related tests",
 227                 "category": "Rust Analyzer"
 228             },
 229             {
 230                 "command": "rust-analyzer.moveItemUp",
 231                 "title": "Move item up",
 232                 "category": "Rust Analyzer"
 233             },
 234             {
 235                 "command": "rust-analyzer.moveItemDown",
 236                 "title": "Move item down",
 237                 "category": "Rust Analyzer"
 238             }
 239         ],
 240         "keybindings": [
 241             {
 242                 "command": "rust-analyzer.parentModule",
 243                 "key": "ctrl+shift+u",
 244                 "when": "editorTextFocus && editorLangId == rust"
 245             },
 246             {
 247                 "command": "rust-analyzer.matchingBrace",
 248                 "key": "ctrl+shift+m",
 249                 "when": "editorTextFocus && editorLangId == rust"
 250             },
 251             {
 252                 "command": "rust-analyzer.joinLines",
 253                 "key": "ctrl+shift+j",
 254                 "when": "editorTextFocus && editorLangId == rust"
 255             }
 256         ],
 257         "configuration": {
 258             "type": "object",
 259             "title": "Rust Analyzer",
 260             "properties": {
 261                 "rust-analyzer.cargoRunner": {
 262                     "type": [
 263                         "null",
 264                         "string"
 265                     ],
 266                     "default": null,
 267                     "description": "Custom cargo runner extension ID."
 268                 },
 269                 "rust-analyzer.runnableEnv": {
 270                     "anyOf": [
 271                         {
 272                             "type": "null"
 273                         },
 274                         {
 275                             "type": "array",
 276                             "items": {
 277                                 "type": "object",
 278                                 "properties": {
 279                                     "mask": {
 280                                         "type": "string",
 281                                         "description": "Runnable name mask"
 282                                     },
 283                                     "env": {
 284                                         "type": "object",
 285                                         "description": "Variables in form of { \"key\": \"value\"}"
 286                                     }
 287                                 }
 288                             }
 289                         },
 290                         {
 291                             "type": "object",
 292                             "description": "Variables in form of { \"key\": \"value\"}"
 293                         }
 294                     ],
 295                     "default": null,
 296                     "markdownDescription": "Environment variables passed to the runnable launched using `Test` or `Debug` lens or `rust-analyzer.run` command."
 297                 },
 298                 "rust-analyzer.server.path": {
 299                     "type": [
 300                         "null",
 301                         "string"
 302                     ],
 303                     "scope": "machine-overridable",
 304                     "default": null,
 305                     "markdownDescription": "Path to rust-analyzer executable (points to bundled binary by default)."
 306                 },
 307                 "rust-analyzer.server.extraEnv": {
 308                     "type": [
 309                         "null",
 310                         "object"
 311                     ],
 312                     "default": null,
 313                     "markdownDescription": "Extra environment variables that will be passed to the rust-analyzer executable. Useful for passing e.g. `RA_LOG` for debugging."
 314                 },
 315                 "rust-analyzer.trace.server": {
 316                     "type": "string",
 317                     "scope": "window",
 318                     "enum": [
 319                         "off",
 320                         "messages",
 321                         "verbose"
 322                     ],
 323                     "enumDescriptions": [
 324                         "No traces",
 325                         "Error only",
 326                         "Full log"
 327                     ],
 328                     "default": "off",
 329                     "description": "Trace requests to the rust-analyzer (this is usually overly verbose and not recommended for regular users)."
 330                 },
 331                 "rust-analyzer.trace.extension": {
 332                     "description": "Enable logging of VS Code extensions itself.",
 333                     "type": "boolean",
 334                     "default": false
 335                 },
 336                 "rust-analyzer.debug.engine": {
 337                     "type": "string",
 338                     "enum": [
 339                         "auto",
 340                         "vadimcn.vscode-lldb",
 341                         "ms-vscode.cpptools"
 342                     ],
 343                     "default": "auto",
 344                     "description": "Preferred debug engine.",
 345                     "markdownEnumDescriptions": [
 346                         "First try to use [CodeLLDB](https://marketplace.visualstudio.com/items?itemName=vadimcn.vscode-lldb), if it's not installed try to use [MS C++ tools](https://marketplace.visualstudio.com/items?itemName=ms-vscode.cpptools).",
 347                         "Use [CodeLLDB](https://marketplace.visualstudio.com/items?itemName=vadimcn.vscode-lldb)",
 348                         "Use [MS C++ tools](https://marketplace.visualstudio.com/items?itemName=ms-vscode.cpptools)"
 349                     ]
 350                 },
 351                 "rust-analyzer.debug.sourceFileMap": {
 352                     "type": [
 353                         "object",
 354                         "string"
 355                     ],
 356                     "const": "auto",
 357                     "description": "Optional source file mappings passed to the debug engine.",
 358                     "default": {
 359                         "/rustc/<id>": "${env:USERPROFILE}/.rustup/toolchains/<toolchain-id>/lib/rustlib/src/rust"
 360                     }
 361                 },
 362                 "rust-analyzer.debug.openDebugPane": {
 363                     "markdownDescription": "Whether to open up the `Debug Panel` on debugging start.",
 364                     "type": "boolean",
 365                     "default": false
 366                 },
 367                 "rust-analyzer.debug.engineSettings": {
 368                     "type": "object",
 369                     "default": {},
 370                     "markdownDescription": "Optional settings passed to the debug engine. Example: `{ \"lldb\": { \"terminal\":\"external\"} }`"
 371                 },
 372                 "$generated-start": {},
 373                 "rust-analyzer.assist.expressionFillDefault": {
 374                     "markdownDescription": "Placeholder expression to use for missing expressions in assists.",
 375                     "default": "todo",
 376                     "type": "string",
 377                     "enum": [
 378                         "todo",
 379                         "default"
 380                     ],
 381                     "enumDescriptions": [
 382                         "Fill missing expressions with the `todo` macro",
 383                         "Fill missing expressions with reasonable defaults, `new` or `default` constructors."
 384                     ]
 385                 },
 386                 "rust-analyzer.cachePriming.enable": {
 387                     "markdownDescription": "Warm up caches on project load.",
 388                     "default": true,
 389                     "type": "boolean"
 390                 },
 391                 "rust-analyzer.cachePriming.numThreads": {
 392                     "markdownDescription": "How many worker threads to to handle priming caches. The default `0` means to pick automatically.",
 393                     "default": 0,
 394                     "type": "number",
 395                     "minimum": 0,
 396                     "maximum": 255
 397                 },
 398                 "rust-analyzer.cargo.autoreload": {
 399                     "markdownDescription": "Automatically refresh project info via `cargo metadata` on\n`Cargo.toml` or `.cargo/config.toml` changes.",
 400                     "default": true,
 401                     "type": "boolean"
 402                 },
 403                 "rust-analyzer.cargo.buildScripts.enable": {
 404                     "markdownDescription": "Run build scripts (`build.rs`) for more precise code analysis.",
 405                     "default": true,
 406                     "type": "boolean"
 407                 },
 408                 "rust-analyzer.cargo.buildScripts.overrideCommand": {
 409                     "markdownDescription": "Override the command rust-analyzer uses to run build scripts and\nbuild procedural macros. The command is required to output json\nand should therefor include `--message-format=json` or a similar\noption.\n\nBy default, a cargo invocation will be constructed for the configured\ntargets and features, with the following base command line:\n\n```bash\ncargo check --quiet --workspace --message-format=json --all-targets\n```\n.",
 410                     "default": null,
 411                     "type": [
 412                         "null",
 413                         "array"
 414                     ],
 415                     "items": {
 416                         "type": "string"
 417                     }
 418                 },
 419                 "rust-analyzer.cargo.buildScripts.useRustcWrapper": {
 420                     "markdownDescription": "Use `RUSTC_WRAPPER=rust-analyzer` when running build scripts to\navoid compiling unnecessary things.",
 421                     "default": true,
 422                     "type": "boolean"
 423                 },
 424                 "rust-analyzer.cargo.features": {
 425                     "markdownDescription": "List of features to activate.\n\nSet this to `\"all\"` to pass `--all-features` to cargo.",
 426                     "default": [],
 427                     "anyOf": [
 428                         {
 429                             "type": "string",
 430                             "enum": [
 431                                 "all"
 432                             ],
 433                             "enumDescriptions": [
 434                                 "Pass `--all-features` to cargo"
 435                             ]
 436                         },
 437                         {
 438                             "type": "array",
 439                             "items": {
 440                                 "type": "string"
 441                             }
 442                         }
 443                     ]
 444                 },
 445                 "rust-analyzer.cargo.noDefaultFeatures": {
 446                     "markdownDescription": "Whether to pass `--no-default-features` to cargo.",
 447                     "default": false,
 448                     "type": "boolean"
 449                 },
 450                 "rust-analyzer.cargo.noSysroot": {
 451                     "markdownDescription": "Internal config for debugging, disables loading of sysroot crates.",
 452                     "default": false,
 453                     "type": "boolean"
 454                 },
 455                 "rust-analyzer.cargo.target": {
 456                     "markdownDescription": "Compilation target override (target triple).",
 457                     "default": null,
 458                     "type": [
 459                         "null",
 460                         "string"
 461                     ]
 462                 },
 463                 "rust-analyzer.cargo.unsetTest": {
 464                     "markdownDescription": "Unsets `#[cfg(test)]` for the specified crates.",
 465                     "default": [
 466                         "core"
 467                     ],
 468                     "type": "array",
 469                     "items": {
 470                         "type": "string"
 471                     }
 472                 },
 473                 "rust-analyzer.checkOnSave.allTargets": {
 474                     "markdownDescription": "Check all targets and tests (`--all-targets`).",
 475                     "default": true,
 476                     "type": "boolean"
 477                 },
 478                 "rust-analyzer.checkOnSave.command": {
 479                     "markdownDescription": "Cargo command to use for `cargo check`.",
 480                     "default": "check",
 481                     "type": "string"
 482                 },
 483                 "rust-analyzer.checkOnSave.enable": {
 484                     "markdownDescription": "Run specified `cargo check` command for diagnostics on save.",
 485                     "default": true,
 486                     "type": "boolean"
 487                 },
 488                 "rust-analyzer.checkOnSave.extraArgs": {
 489                     "markdownDescription": "Extra arguments for `cargo check`.",
 490                     "default": [],
 491                     "type": "array",
 492                     "items": {
 493                         "type": "string"
 494                     }
 495                 },
 496                 "rust-analyzer.checkOnSave.features": {
 497                     "markdownDescription": "List of features to activate. Defaults to\n`#rust-analyzer.cargo.features#`.\n\nSet to `\"all\"` to pass `--all-features` to cargo.",
 498                     "default": null,
 499                     "anyOf": [
 500                         {
 501                             "type": "string",
 502                             "enum": [
 503                                 "all"
 504                             ],
 505                             "enumDescriptions": [
 506                                 "Pass `--all-features` to cargo"
 507                             ]
 508                         },
 509                         {
 510                             "type": "array",
 511                             "items": {
 512                                 "type": "string"
 513                             }
 514                         },
 515                         {
 516                             "type": "null"
 517                         }
 518                     ]
 519                 },
 520                 "rust-analyzer.checkOnSave.noDefaultFeatures": {
 521                     "markdownDescription": "Whether to pass `--no-default-features` to cargo. Defaults to\n`#rust-analyzer.cargo.noDefaultFeatures#`.",
 522                     "default": null,
 523                     "type": [
 524                         "null",
 525                         "boolean"
 526                     ]
 527                 },
 528                 "rust-analyzer.checkOnSave.overrideCommand": {
 529                     "markdownDescription": "Override the command rust-analyzer uses to    run build scripts and\nbuild procedural macros. The command is required to output json\nand should therefor include `--message-format=json` or a similar\noption.\n\nAn example command would be:\n\n```bash\ncargo check --workspace --message-format=json --all-targets\n```\n.",
 530                     "default": null,
 531                     "type": [
 532                         "null",
 533                         "array"
 534                     ],
 535                     "items": {
 536                         "type": "string"
 537                     }
 538                 },
 539                 "rust-analyzer.checkOnSave.target": {
 540                     "markdownDescription": "Check for a specific target. Defaults to\n`#rust-analyzer.cargo.target#`.",
 541                     "default": null,
 542                     "type": [
 543                         "null",
 544                         "string"
 545                     ]
 546                 },
 547                 "rust-analyzer.completion.autoimport.enable": {
 548                     "markdownDescription": "Toggles the additional completions that automatically add imports when completed.\nNote that your client must specify the `additionalTextEdits` LSP client capability to truly have this feature enabled.",
 549                     "default": true,
 550                     "type": "boolean"
 551                 },
 552                 "rust-analyzer.completion.autoself.enable": {
 553                     "markdownDescription": "Toggles the additional completions that automatically show method calls and field accesses\nwith `self` prefixed to them when inside a method.",
 554                     "default": true,
 555                     "type": "boolean"
 556                 },
 557                 "rust-analyzer.completion.callable.snippets": {
 558                     "markdownDescription": "Whether to add parenthesis and argument snippets when completing function.",
 559                     "default": "fill_arguments",
 560                     "type": "string",
 561                     "enum": [
 562                         "fill_arguments",
 563                         "add_parentheses",
 564                         "none"
 565                     ],
 566                     "enumDescriptions": [
 567                         "Add call parentheses and pre-fill arguments.",
 568                         "Add call parentheses.",
 569                         "Do no snippet completions for callables."
 570                     ]
 571                 },
 572                 "rust-analyzer.completion.postfix.enable": {
 573                     "markdownDescription": "Whether to show postfix snippets like `dbg`, `if`, `not`, etc.",
 574                     "default": true,
 575                     "type": "boolean"
 576                 },
 577                 "rust-analyzer.completion.privateEditable.enable": {
 578                     "markdownDescription": "Enables completions of private items and fields that are defined in the current workspace even if they are not visible at the current position.",
 579                     "default": false,
 580                     "type": "boolean"
 581                 },
 582                 "rust-analyzer.completion.snippets.custom": {
 583                     "markdownDescription": "Custom completion snippets.",
 584                     "default": {
 585                         "Arc::new": {
 586                             "postfix": "arc",
 587                             "body": "Arc::new(${receiver})",
 588                             "requires": "std::sync::Arc",
 589                             "description": "Put the expression into an `Arc`",
 590                             "scope": "expr"
 591                         },
 592                         "Rc::new": {
 593                             "postfix": "rc",
 594                             "body": "Rc::new(${receiver})",
 595                             "requires": "std::rc::Rc",
 596                             "description": "Put the expression into an `Rc`",
 597                             "scope": "expr"
 598                         },
 599                         "Box::pin": {
 600                             "postfix": "pinbox",
 601                             "body": "Box::pin(${receiver})",
 602                             "requires": "std::boxed::Box",
 603                             "description": "Put the expression into a pinned `Box`",
 604                             "scope": "expr"
 605                         },
 606                         "Ok": {
 607                             "postfix": "ok",
 608                             "body": "Ok(${receiver})",
 609                             "description": "Wrap the expression in a `Result::Ok`",
 610                             "scope": "expr"
 611                         },
 612                         "Err": {
 613                             "postfix": "err",
 614                             "body": "Err(${receiver})",
 615                             "description": "Wrap the expression in a `Result::Err`",
 616                             "scope": "expr"
 617                         },
 618                         "Some": {
 619                             "postfix": "some",
 620                             "body": "Some(${receiver})",
 621                             "description": "Wrap the expression in an `Option::Some`",
 622                             "scope": "expr"
 623                         }
 624                     },
 625                     "type": "object"
 626                 },
 627                 "rust-analyzer.diagnostics.disabled": {
 628                     "markdownDescription": "List of rust-analyzer diagnostics to disable.",
 629                     "default": [],
 630                     "type": "array",
 631                     "items": {
 632                         "type": "string"
 633                     },
 634                     "uniqueItems": true
 635                 },
 636                 "rust-analyzer.diagnostics.enable": {
 637                     "markdownDescription": "Whether to show native rust-analyzer diagnostics.",
 638                     "default": true,
 639                     "type": "boolean"
 640                 },
 641                 "rust-analyzer.diagnostics.experimental.enable": {
 642                     "markdownDescription": "Whether to show experimental rust-analyzer diagnostics that might\nhave more false positives than usual.",
 643                     "default": false,
 644                     "type": "boolean"
 645                 },
 646                 "rust-analyzer.diagnostics.remapPrefix": {
 647                     "markdownDescription": "Map of prefixes to be substituted when parsing diagnostic file paths.\nThis should be the reverse mapping of what is passed to `rustc` as `--remap-path-prefix`.",
 648                     "default": {},
 649                     "type": "object"
 650                 },
 651                 "rust-analyzer.diagnostics.warningsAsHint": {
 652                     "markdownDescription": "List of warnings that should be displayed with hint severity.\n\nThe warnings will be indicated by faded text or three dots in code\nand will not show up in the `Problems Panel`.",
 653                     "default": [],
 654                     "type": "array",
 655                     "items": {
 656                         "type": "string"
 657                     }
 658                 },
 659                 "rust-analyzer.diagnostics.warningsAsInfo": {
 660                     "markdownDescription": "List of warnings that should be displayed with info severity.\n\nThe warnings will be indicated by a blue squiggly underline in code\nand a blue icon in the `Problems Panel`.",
 661                     "default": [],
 662                     "type": "array",
 663                     "items": {
 664                         "type": "string"
 665                     }
 666                 },
 667                 "rust-analyzer.files.excludeDirs": {
 668                     "markdownDescription": "These directories will be ignored by rust-analyzer. They are\nrelative to the workspace root, and globs are not supported. You may\nalso need to add the folders to Code's `files.watcherExclude`.",
 669                     "default": [],
 670                     "type": "array",
 671                     "items": {
 672                         "type": "string"
 673                     }
 674                 },
 675                 "rust-analyzer.files.watcher": {
 676                     "markdownDescription": "Controls file watching implementation.",
 677                     "default": "client",
 678                     "type": "string"
 679                 },
 680                 "rust-analyzer.highlightRelated.breakPoints.enable": {
 681                     "markdownDescription": "Enables highlighting of related references while the cursor is on `break`, `loop`, `while`, or `for` keywords.",
 682                     "default": true,
 683                     "type": "boolean"
 684                 },
 685                 "rust-analyzer.highlightRelated.exitPoints.enable": {
 686                     "markdownDescription": "Enables highlighting of all exit points while the cursor is on any `return`, `?`, `fn`, or return type arrow (`->`).",
 687                     "default": true,
 688                     "type": "boolean"
 689                 },
 690                 "rust-analyzer.highlightRelated.references.enable": {
 691                     "markdownDescription": "Enables highlighting of related references while the cursor is on any identifier.",
 692                     "default": true,
 693                     "type": "boolean"
 694                 },
 695                 "rust-analyzer.highlightRelated.yieldPoints.enable": {
 696                     "markdownDescription": "Enables highlighting of all break points for a loop or block context while the cursor is on any `async` or `await` keywords.",
 697                     "default": true,
 698                     "type": "boolean"
 699                 },
 700                 "rust-analyzer.hover.actions.debug.enable": {
 701                     "markdownDescription": "Whether to show `Debug` action. Only applies when\n`#rust-analyzer.hover.actions.enable#` is set.",
 702                     "default": true,
 703                     "type": "boolean"
 704                 },
 705                 "rust-analyzer.hover.actions.enable": {
 706                     "markdownDescription": "Whether to show HoverActions in Rust files.",
 707                     "default": true,
 708                     "type": "boolean"
 709                 },
 710                 "rust-analyzer.hover.actions.gotoTypeDef.enable": {
 711                     "markdownDescription": "Whether to show `Go to Type Definition` action. Only applies when\n`#rust-analyzer.hover.actions.enable#` is set.",
 712                     "default": true,
 713                     "type": "boolean"
 714                 },
 715                 "rust-analyzer.hover.actions.implementations.enable": {
 716                     "markdownDescription": "Whether to show `Implementations` action. Only applies when\n`#rust-analyzer.hover.actions.enable#` is set.",
 717                     "default": true,
 718                     "type": "boolean"
 719                 },
 720                 "rust-analyzer.hover.actions.references.enable": {
 721                     "markdownDescription": "Whether to show `References` action. Only applies when\n`#rust-analyzer.hover.actions.enable#` is set.",
 722                     "default": false,
 723                     "type": "boolean"
 724                 },
 725                 "rust-analyzer.hover.actions.run.enable": {
 726                     "markdownDescription": "Whether to show `Run` action. Only applies when\n`#rust-analyzer.hover.actions.enable#` is set.",
 727                     "default": true,
 728                     "type": "boolean"
 729                 },
 730                 "rust-analyzer.hover.documentation.enable": {
 731                     "markdownDescription": "Whether to show documentation on hover.",
 732                     "default": true,
 733                     "type": "boolean"
 734                 },
 735                 "rust-analyzer.hover.links.enable": {
 736                     "markdownDescription": "Use markdown syntax for links in hover.",
 737                     "default": true,
 738                     "type": "boolean"
 739                 },
 740                 "rust-analyzer.imports.granularity.enforce": {
 741                     "markdownDescription": "Whether to enforce the import granularity setting for all files. If set to false rust-analyzer will try to keep import styles consistent per file.",
 742                     "default": false,
 743                     "type": "boolean"
 744                 },
 745                 "rust-analyzer.imports.granularity.group": {
 746                     "markdownDescription": "How imports should be grouped into use statements.",
 747                     "default": "crate",
 748                     "type": "string",
 749                     "enum": [
 750                         "preserve",
 751                         "crate",
 752                         "module",
 753                         "item"
 754                     ],
 755                     "enumDescriptions": [
 756                         "Do not change the granularity of any imports and preserve the original structure written by the developer.",
 757                         "Merge imports from the same crate into a single use statement. Conversely, imports from different crates are split into separate statements.",
 758                         "Merge imports from the same module into a single use statement. Conversely, imports from different modules are split into separate statements.",
 759                         "Flatten imports so that each has its own use statement."
 760                     ]
 761                 },
 762                 "rust-analyzer.imports.group.enable": {
 763                     "markdownDescription": "Group inserted imports by the [following order](https://rust-analyzer.github.io/manual.html#auto-import). Groups are separated by newlines.",
 764                     "default": true,
 765                     "type": "boolean"
 766                 },
 767                 "rust-analyzer.imports.merge.glob": {
 768                     "markdownDescription": "Whether to allow import insertion to merge new imports into single path glob imports like `use std::fmt::*;`.",
 769                     "default": true,
 770                     "type": "boolean"
 771                 },
 772                 "rust-analyzer.imports.prefix": {
 773                     "markdownDescription": "The path structure for newly inserted paths to use.",
 774                     "default": "plain",
 775                     "type": "string",
 776                     "enum": [
 777                         "plain",
 778                         "self",
 779                         "crate"
 780                     ],
 781                     "enumDescriptions": [
 782                         "Insert import paths relative to the current module, using up to one `super` prefix if the parent module contains the requested item.",
 783                         "Insert import paths relative to the current module, using up to one `super` prefix if the parent module contains the requested item. Prefixes `self` in front of the path if it starts with a module.",
 784                         "Force import paths to be absolute by always starting them with `crate` or the extern crate name they come from."
 785                     ]
 786                 },
 787                 "rust-analyzer.inlayHints.bindingModeHints.enable": {
 788                     "markdownDescription": "Whether to show inlay type hints for binding modes.",
 789                     "default": false,
 790                     "type": "boolean"
 791                 },
 792                 "rust-analyzer.inlayHints.chainingHints.enable": {
 793                     "markdownDescription": "Whether to show inlay type hints for method chains.",
 794                     "default": true,
 795                     "type": "boolean"
 796                 },
 797                 "rust-analyzer.inlayHints.closingBraceHints.enable": {
 798                     "markdownDescription": "Whether to show inlay hints after a closing `}` to indicate what item it belongs to.",
 799                     "default": true,
 800                     "type": "boolean"
 801                 },
 802                 "rust-analyzer.inlayHints.closingBraceHints.minLines": {
 803                     "markdownDescription": "Minimum number of lines required before the `}` until the hint is shown (set to 0 or 1\nto always show them).",
 804                     "default": 25,
 805                     "type": "integer",
 806                     "minimum": 0
 807                 },
 808                 "rust-analyzer.inlayHints.closureReturnTypeHints.enable": {
 809                     "markdownDescription": "Whether to show inlay type hints for return types of closures with blocks.",
 810                     "default": false,
 811                     "type": "boolean"
 812                 },
 813                 "rust-analyzer.inlayHints.lifetimeElisionHints.enable": {
 814                     "markdownDescription": "Whether to show inlay type hints for elided lifetimes in function signatures.",
 815                     "default": "never",
 816                     "type": "string",
 817                     "enum": [
 818                         "always",
 819                         "never",
 820                         "skip_trivial"
 821                     ],
 822                     "enumDescriptions": [
 823                         "Always show lifetime elision hints.",
 824                         "Never show lifetime elision hints.",
 825                         "Only show lifetime elision hints if a return type is involved."
 826                     ]
 827                 },
 828                 "rust-analyzer.inlayHints.lifetimeElisionHints.useParameterNames": {
 829                     "markdownDescription": "Whether to prefer using parameter names as the name for elided lifetime hints if possible.",
 830                     "default": false,
 831                     "type": "boolean"
 832                 },
 833                 "rust-analyzer.inlayHints.maxLength": {
 834                     "markdownDescription": "Maximum length for inlay hints. Set to null to have an unlimited length.",
 835                     "default": 25,
 836                     "type": [
 837                         "null",
 838                         "integer"
 839                     ],
 840                     "minimum": 0
 841                 },
 842                 "rust-analyzer.inlayHints.parameterHints.enable": {
 843                     "markdownDescription": "Whether to show function parameter name inlay hints at the call\nsite.",
 844                     "default": true,
 845                     "type": "boolean"
 846                 },
 847                 "rust-analyzer.inlayHints.reborrowHints.enable": {
 848                     "markdownDescription": "Whether to show inlay type hints for compiler inserted reborrows.",
 849                     "default": "never",
 850                     "type": "string",
 851                     "enum": [
 852                         "always",
 853                         "never",
 854                         "mutable"
 855                     ],
 856                     "enumDescriptions": [
 857                         "Always show reborrow hints.",
 858                         "Never show reborrow hints.",
 859                         "Only show mutable reborrow hints."
 860                     ]
 861                 },
 862                 "rust-analyzer.inlayHints.renderColons": {
 863                     "markdownDescription": "Whether to render leading colons for type hints, and trailing colons for parameter hints.",
 864                     "default": true,
 865                     "type": "boolean"
 866                 },
 867                 "rust-analyzer.inlayHints.typeHints.enable": {
 868                     "markdownDescription": "Whether to show inlay type hints for variables.",
 869                     "default": true,
 870                     "type": "boolean"
 871                 },
 872                 "rust-analyzer.inlayHints.typeHints.hideNamedConstructor": {
 873                     "markdownDescription": "Whether to hide inlay type hints for constructors.",
 874                     "default": false,
 875                     "type": "boolean"
 876                 },
 877                 "rust-analyzer.joinLines.joinAssignments": {
 878                     "markdownDescription": "Join lines merges consecutive declaration and initialization of an assignment.",
 879                     "default": true,
 880                     "type": "boolean"
 881                 },
 882                 "rust-analyzer.joinLines.joinElseIf": {
 883                     "markdownDescription": "Join lines inserts else between consecutive ifs.",
 884                     "default": true,
 885                     "type": "boolean"
 886                 },
 887                 "rust-analyzer.joinLines.removeTrailingComma": {
 888                     "markdownDescription": "Join lines removes trailing commas.",
 889                     "default": true,
 890                     "type": "boolean"
 891                 },
 892                 "rust-analyzer.joinLines.unwrapTrivialBlock": {
 893                     "markdownDescription": "Join lines unwraps trivial blocks.",
 894                     "default": true,
 895                     "type": "boolean"
 896                 },
 897                 "rust-analyzer.lens.debug.enable": {
 898                     "markdownDescription": "Whether to show `Debug` lens. Only applies when\n`#rust-analyzer.lens.enable#` is set.",
 899                     "default": true,
 900                     "type": "boolean"
 901                 },
 902                 "rust-analyzer.lens.enable": {
 903                     "markdownDescription": "Whether to show CodeLens in Rust files.",
 904                     "default": true,
 905                     "type": "boolean"
 906                 },
 907                 "rust-analyzer.lens.forceCustomCommands": {
 908                     "markdownDescription": "Internal config: use custom client-side commands even when the\nclient doesn't set the corresponding capability.",
 909                     "default": true,
 910                     "type": "boolean"
 911                 },
 912                 "rust-analyzer.lens.implementations.enable": {
 913                     "markdownDescription": "Whether to show `Implementations` lens. Only applies when\n`#rust-analyzer.lens.enable#` is set.",
 914                     "default": true,
 915                     "type": "boolean"
 916                 },
 917                 "rust-analyzer.lens.references.adt.enable": {
 918                     "markdownDescription": "Whether to show `References` lens for Struct, Enum, and Union.\nOnly applies when `#rust-analyzer.lens.enable#` is set.",
 919                     "default": false,
 920                     "type": "boolean"
 921                 },
 922                 "rust-analyzer.lens.references.enumVariant.enable": {
 923                     "markdownDescription": "Whether to show `References` lens for Enum Variants.\nOnly applies when `#rust-analyzer.lens.enable#` is set.",
 924                     "default": false,
 925                     "type": "boolean"
 926                 },
 927                 "rust-analyzer.lens.references.method.enable": {
 928                     "markdownDescription": "Whether to show `Method References` lens. Only applies when\n`#rust-analyzer.lens.enable#` is set.",
 929                     "default": false,
 930                     "type": "boolean"
 931                 },
 932                 "rust-analyzer.lens.references.trait.enable": {
 933                     "markdownDescription": "Whether to show `References` lens for Trait.\nOnly applies when `#rust-analyzer.lens.enable#` is set.",
 934                     "default": false,
 935                     "type": "boolean"
 936                 },
 937                 "rust-analyzer.lens.run.enable": {
 938                     "markdownDescription": "Whether to show `Run` lens. Only applies when\n`#rust-analyzer.lens.enable#` is set.",
 939                     "default": true,
 940                     "type": "boolean"
 941                 },
 942                 "rust-analyzer.linkedProjects": {
 943                     "markdownDescription": "Disable project auto-discovery in favor of explicitly specified set\nof projects.\n\nElements must be paths pointing to `Cargo.toml`,\n`rust-project.json`, or JSON objects in `rust-project.json` format.",
 944                     "default": [],
 945                     "type": "array",
 946                     "items": {
 947                         "type": [
 948                             "string",
 949                             "object"
 950                         ]
 951                     }
 952                 },
 953                 "rust-analyzer.lru.capacity": {
 954                     "markdownDescription": "Number of syntax trees rust-analyzer keeps in memory. Defaults to 128.",
 955                     "default": null,
 956                     "type": [
 957                         "null",
 958                         "integer"
 959                     ],
 960                     "minimum": 0
 961                 },
 962                 "rust-analyzer.notifications.cargoTomlNotFound": {
 963                     "markdownDescription": "Whether to show `can't find Cargo.toml` error message.",
 964                     "default": true,
 965                     "type": "boolean"
 966                 },
 967                 "rust-analyzer.procMacro.attributes.enable": {
 968                     "markdownDescription": "Expand attribute macros. Requires `#rust-analyzer.procMacro.enable#` to be set.",
 969                     "default": true,
 970                     "type": "boolean"
 971                 },
 972                 "rust-analyzer.procMacro.enable": {
 973                     "markdownDescription": "Enable support for procedural macros, implies `#rust-analyzer.cargo.buildScripts.enable#`.",
 974                     "default": true,
 975                     "type": "boolean"
 976                 },
 977                 "rust-analyzer.procMacro.ignored": {
 978                     "markdownDescription": "These proc-macros will be ignored when trying to expand them.\n\nThis config takes a map of crate names with the exported proc-macro names to ignore as values.",
 979                     "default": {},
 980                     "type": "object"
 981                 },
 982                 "rust-analyzer.procMacro.server": {
 983                     "markdownDescription": "Internal config, path to proc-macro server executable (typically,\nthis is rust-analyzer itself, but we override this in tests).",
 984                     "default": null,
 985                     "type": [
 986                         "null",
 987                         "string"
 988                     ]
 989                 },
 990                 "rust-analyzer.runnables.command": {
 991                     "markdownDescription": "Command to be executed instead of 'cargo' for runnables.",
 992                     "default": null,
 993                     "type": [
 994                         "null",
 995                         "string"
 996                     ]
 997                 },
 998                 "rust-analyzer.runnables.extraArgs": {
 999                     "markdownDescription": "Additional arguments to be passed to cargo for runnables such as\ntests or binaries. For example, it may be `--release`.",
1000                     "default": [],
1001                     "type": "array",
1002                     "items": {
1003                         "type": "string"
1004                     }
1005                 },
1006                 "rust-analyzer.rustc.source": {
1007                     "markdownDescription": "Path to the Cargo.toml of the rust compiler workspace, for usage in rustc_private\nprojects, or \"discover\" to try to automatically find it if the `rustc-dev` component\nis installed.\n\nAny project which uses rust-analyzer with the rustcPrivate\ncrates must set `[package.metadata.rust-analyzer] rustc_private=true` to use it.\n\nThis option does not take effect until rust-analyzer is restarted.",
1008                     "default": null,
1009                     "type": [
1010                         "null",
1011                         "string"
1012                     ]
1013                 },
1014                 "rust-analyzer.rustfmt.extraArgs": {
1015                     "markdownDescription": "Additional arguments to `rustfmt`.",
1016                     "default": [],
1017                     "type": "array",
1018                     "items": {
1019                         "type": "string"
1020                     }
1021                 },
1022                 "rust-analyzer.rustfmt.overrideCommand": {
1023                     "markdownDescription": "Advanced option, fully override the command rust-analyzer uses for\nformatting.",
1024                     "default": null,
1025                     "type": [
1026                         "null",
1027                         "array"
1028                     ],
1029                     "items": {
1030                         "type": "string"
1031                     }
1032                 },
1033                 "rust-analyzer.rustfmt.rangeFormatting.enable": {
1034                     "markdownDescription": "Enables the use of rustfmt's unstable range formatting command for the\n`textDocument/rangeFormatting` request. The rustfmt option is unstable and only\navailable on a nightly build.",
1035                     "default": false,
1036                     "type": "boolean"
1037                 },
1038                 "rust-analyzer.semanticHighlighting.strings.enable": {
1039                     "markdownDescription": "Use semantic tokens for strings.\n\nIn some editors (e.g. vscode) semantic tokens override other highlighting grammars.\nBy disabling semantic tokens for strings, other grammars can be used to highlight\ntheir contents.",
1040                     "default": true,
1041                     "type": "boolean"
1042                 },
1043                 "rust-analyzer.signatureInfo.detail": {
1044                     "markdownDescription": "Show full signature of the callable. Only shows parameters if disabled.",
1045                     "default": "full",
1046                     "type": "string",
1047                     "enum": [
1048                         "full",
1049                         "parameters"
1050                     ],
1051                     "enumDescriptions": [
1052                         "Show the entire signature.",
1053                         "Show only the parameters."
1054                     ]
1055                 },
1056                 "rust-analyzer.signatureInfo.documentation.enable": {
1057                     "markdownDescription": "Show documentation.",
1058                     "default": true,
1059                     "type": "boolean"
1060                 },
1061                 "rust-analyzer.workspace.symbol.search.kind": {
1062                     "markdownDescription": "Workspace symbol search kind.",
1063                     "default": "only_types",
1064                     "type": "string",
1065                     "enum": [
1066                         "only_types",
1067                         "all_symbols"
1068                     ],
1069                     "enumDescriptions": [
1070                         "Search for types only.",
1071                         "Search for all symbols kinds."
1072                     ]
1073                 },
1074                 "rust-analyzer.workspace.symbol.search.limit": {
1075                     "markdownDescription": "Limits the number of items returned from a workspace symbol search (Defaults to 128).\nSome clients like vs-code issue new searches on result filtering and don't require all results to be returned in the initial search.\nOther clients requires all results upfront and might require a higher limit.",
1076                     "default": 128,
1077                     "type": "integer",
1078                     "minimum": 0
1079                 },
1080                 "rust-analyzer.workspace.symbol.search.scope": {
1081                     "markdownDescription": "Workspace symbol search scope.",
1082                     "default": "workspace",
1083                     "type": "string",
1084                     "enum": [
1085                         "workspace",
1086                         "workspace_and_dependencies"
1087                     ],
1088                     "enumDescriptions": [
1089                         "Search in current workspace only.",
1090                         "Search in current workspace and dependencies."
1091                     ]
1092                 },
1093                 "$generated-end": {}
1094             }
1095         },
1096         "problemPatterns": [
1097             {
1098                 "name": "rustc",
1099                 "patterns": [
1100                     {
1101                         "regexp": "^(warning|warn|error)(?:\\[(.*?)\\])?: (.*)$",
1102                         "severity": 1,
1103                         "code": 2,
1104                         "message": 3
1105                     },
1106                     {
1107                         "regexp": "^[\\s->=]*(.*?):(\\d*):(\\d*)\\s*$",
1108                         "file": 1,
1109                         "line": 2,
1110                         "column": 3
1111                     }
1112                 ]
1113             },
1114             {
1115                 "name": "rustc-json",
1116                 "patterns": [
1117                     {
1118                         "regexp": "^.*\"message\":{\"message\":\"([^\"]*).*?\"file_name\":\"([^\"]+).*?\"line_start\":(\\d+).*?\"line_end\":(\\d+).*?\"column_start\":(\\d+).*?\"column_end\":(\\d+).*}$",
1119                         "message": 1,
1120                         "file": 2,
1121                         "line": 3,
1122                         "endLine": 4,
1123                         "column": 5,
1124                         "endColumn": 6
1125                     }
1126                 ]
1127             }
1128         ],
1129         "languages": [
1130             {
1131                 "id": "ra_syntax_tree",
1132                 "extensions": [
1133                     ".rast"
1134                 ]
1135             },
1136             {
1137                 "id": "rust",
1138                 "extensions": [
1139                     ".rs"
1140                 ],
1141                 "aliases": [
1142                     "Rust",
1143                     "rs"
1144                 ],
1145                 "configuration": "language-configuration.json"
1146             }
1147         ],
1148         "grammars": [
1149             {
1150                 "language": "ra_syntax_tree",
1151                 "scopeName": "source.ra_syntax_tree",
1152                 "path": "ra_syntax_tree.tmGrammar.json"
1153             }
1154         ],
1155         "problemMatchers": [
1156             {
1157                 "name": "rustc",
1158                 "owner": "rustc",
1159                 "source": "rustc",
1160                 "fileLocation": [
1161                     "autoDetect",
1162                     "${workspaceRoot}"
1163                 ],
1164                 "pattern": "$rustc"
1165             },
1166             {
1167                 "name": "rustc-json",
1168                 "owner": "rustc",
1169                 "source": "rustc",
1170                 "fileLocation": [
1171                     "autoDetect",
1172                     "${workspaceRoot}"
1173                 ],
1174                 "pattern": "$rustc-json"
1175             },
1176             {
1177                 "name": "rustc-watch",
1178                 "owner": "rustc",
1179                 "source": "rustc",
1180                 "fileLocation": [
1181                     "autoDetect",
1182                     "${workspaceRoot}"
1183                 ],
1184                 "background": {
1185                     "beginsPattern": "^\\[Running\\b",
1186                     "endsPattern": "^\\[Finished running\\b"
1187                 },
1188                 "pattern": "$rustc"
1189             }
1190         ],
1191         "colors": [
1192             {
1193                 "id": "rust_analyzer.syntaxTreeBorder",
1194                 "description": "Color of the border displayed in the Rust source code for the selected syntax node (see \"Show Syntax Tree\" command)",
1195                 "defaults": {
1196                     "dark": "#ffffff",
1197                     "light": "#b700ff",
1198                     "highContrast": "#b700ff"
1199                 }
1200             }
1201         ],
1202         "semanticTokenTypes": [
1203             {
1204                 "id": "angle",
1205                 "description": "Style for < or >",
1206                 "superType": "punctuation"
1207             },
1208             {
1209                 "id": "arithmetic",
1210                 "description": "Style for arithmetic operators",
1211                 "superType": "operator"
1212             },
1213             {
1214                 "id": "attribute",
1215                 "description": "Style for attributes"
1216             },
1217             {
1218                 "id": "attributeBracket",
1219                 "description": "Style for attribute invocation brackets, that is the `#[` and `]` tokens",
1220                 "superType": "punctuation"
1221             },
1222             {
1223                 "id": "bitwise",
1224                 "description": "Style for bitwise operators",
1225                 "superType": "operator"
1226             },
1227             {
1228                 "id": "boolean",
1229                 "description": "Style for boolean literals",
1230                 "superType": "keyword"
1231             },
1232             {
1233                 "id": "brace",
1234                 "description": "Style for { or }",
1235                 "superType": "punctuation"
1236             },
1237             {
1238                 "id": "bracket",
1239                 "description": "Style for [ or ]",
1240                 "superType": "punctuation"
1241             },
1242             {
1243                 "id": "builtinAttribute",
1244                 "description": "Style for builtin attributes",
1245                 "superType": "attribute"
1246             },
1247             {
1248                 "id": "builtinType",
1249                 "description": "Style for builtin types",
1250                 "superType": "type"
1251             },
1252             {
1253                 "id": "character",
1254                 "description": "Style for character literals",
1255                 "superType": "string"
1256             },
1257             {
1258                 "id": "colon",
1259                 "description": "Style for :",
1260                 "superType": "punctuation"
1261             },
1262             {
1263                 "id": "comma",
1264                 "description": "Style for ,",
1265                 "superType": "punctuation"
1266             },
1267             {
1268                 "id": "comparison",
1269                 "description": "Style for comparison operators",
1270                 "superType": "operator"
1271             },
1272             {
1273                 "id": "constParameter",
1274                 "description": "Style for const generics"
1275             },
1276             {
1277                 "id": "derive",
1278                 "description": "Style for derives",
1279                 "superType": "attribute"
1280             },
1281             {
1282                 "id": "dot",
1283                 "description": "Style for .",
1284                 "superType": "punctuation"
1285             },
1286             {
1287                 "id": "escapeSequence",
1288                 "description": "Style for char escapes in strings"
1289             },
1290             {
1291                 "id": "formatSpecifier",
1292                 "description": "Style for {} placeholders in format strings"
1293             },
1294             {
1295                 "id": "label",
1296                 "description": "Style for labels"
1297             },
1298             {
1299                 "id": "lifetime",
1300                 "description": "Style for lifetimes"
1301             },
1302             {
1303                 "id": "logical",
1304                 "description": "Style for logic operators",
1305                 "superType": "operator"
1306             },
1307             {
1308                 "id": "macroBang",
1309                 "description": "Style for the ! token of macro calls",
1310                 "superType": "punctuation"
1311             },
1312             {
1313                 "id": "operator",
1314                 "description": "Style for operators",
1315                 "superType": "punctuation"
1316             },
1317             {
1318                 "id": "parenthesis",
1319                 "description": "Style for ( or )",
1320                 "superType": "punctuation"
1321             },
1322             {
1323                 "id": "punctuation",
1324                 "description": "Style for generic punctuation"
1325             },
1326             {
1327                 "id": "selfKeyword",
1328                 "description": "Style for the self keyword",
1329                 "superType": "keyword"
1330             },
1331             {
1332                 "id": "selfTypeKeyword",
1333                 "description": "Style for the self type keyword",
1334                 "superType": "keyword"
1335             },
1336             {
1337                 "id": "semicolon",
1338                 "description": "Style for ;",
1339                 "superType": "punctuation"
1340             },
1341             {
1342                 "id": "typeAlias",
1343                 "description": "Style for type aliases",
1344                 "superType": "type"
1345             },
1346             {
1347                 "id": "union",
1348                 "description": "Style for C-style untagged unions",
1349                 "superType": "type"
1350             },
1351             {
1352                 "id": "unresolvedReference",
1353                 "description": "Style for names which can not be resolved due to compilation errors"
1354             }
1355         ],
1356         "semanticTokenModifiers": [
1357             {
1358                 "id": "async",
1359                 "description": "Style for async functions and the `async` and `await` keywords"
1360             },
1361             {
1362                 "id": "attribute",
1363                 "description": "Style for elements within attributes"
1364             },
1365             {
1366                 "id": "callable",
1367                 "description": "Style for locals whose types implements one of the `Fn*` traits"
1368             },
1369             {
1370                 "id": "constant",
1371                 "description": "Style for compile-time constants"
1372             },
1373             {
1374                 "id": "consuming",
1375                 "description": "Style for locals that are being consumed when use in a function call"
1376             },
1377             {
1378                 "id": "controlFlow",
1379                 "description": "Style for control-flow related tokens, this includes the `?` operator"
1380             },
1381             {
1382                 "id": "crateRoot",
1383                 "description": "Style for names resolving to a crate root"
1384             },
1385             {
1386                 "id": "injected",
1387                 "description": "Style for doc-string injected highlighting like rust source blocks in documentation"
1388             },
1389             {
1390                 "id": "intraDocLink",
1391                 "description": "Style for intra doc links in doc-strings"
1392             },
1393             {
1394                 "id": "library",
1395                 "description": "Style for items that are defined outside of the current crate"
1396             },
1397             {
1398                 "id": "mutable",
1399                 "description": "Style for mutable locals and statics as well as functions taking `&mut self`"
1400             },
1401             {
1402                 "id": "public",
1403                 "description": "Style tems that are from the current crate and are `pub`"
1404             },
1405             {
1406                 "id": "reference",
1407                 "description": "Style for locals behind a reference and functions taking `self` by reference"
1408             },
1409             {
1410                 "id": "trait",
1411                 "description": "Style for associated trait items"
1412             },
1413             {
1414                 "id": "unsafe",
1415                 "description": "Style for unsafe operations, like unsafe function calls, as well as the `unsafe` token"
1416             }
1417         ],
1418         "semanticTokenScopes": [
1419             {
1420                 "language": "rust",
1421                 "scopes": {
1422                     "attribute": [
1423                         "meta.attribute.rust"
1424                     ],
1425                     "boolean": [
1426                         "constant.language.boolean.rust"
1427                     ],
1428                     "builtinType": [
1429                         "support.type.primitive.rust"
1430                     ],
1431                     "constParameter": [
1432                         "constant.other.caps.rust"
1433                     ],
1434                     "enum": [
1435                         "entity.name.type.enum.rust"
1436                     ],
1437                     "formatSpecifier": [
1438                         "punctuation.section.embedded.rust"
1439                     ],
1440                     "function": [
1441                         "entity.name.function.rust"
1442                     ],
1443                     "interface": [
1444                         "entity.name.type.trait.rust"
1445                     ],
1446                     "keyword": [
1447                         "keyword.other.rust"
1448                     ],
1449                     "keyword.controlFlow": [
1450                         "keyword.control.rust"
1451                     ],
1452                     "lifetime": [
1453                         "storage.modifier.lifetime.rust"
1454                     ],
1455                     "macroBang": [
1456                         "entity.name.function.macro.rust"
1457                     ],
1458                     "method": [
1459                         "entity.name.function.rust"
1460                     ],
1461                     "struct": [
1462                         "entity.name.type.struct.rust"
1463                     ],
1464                     "typeAlias": [
1465                         "entity.name.type.declaration.rust"
1466                     ],
1467                     "union": [
1468                         "entity.name.type.union.rust"
1469                     ],
1470                     "variable": [
1471                         "variable.other.rust"
1472                     ],
1473                     "variable.constant": [
1474                         "variable.other.constant.rust"
1475                     ],
1476                     "*.mutable": [
1477                         "markup.underline"
1478                     ]
1479                 }
1480             }
1481         ],
1482         "menus": {
1483             "commandPalette": [
1484                 {
1485                     "command": "rust-analyzer.syntaxTree",
1486                     "when": "inRustProject"
1487                 },
1488                 {
1489                     "command": "rust-analyzer.viewHir",
1490                     "when": "inRustProject"
1491                 },
1492                 {
1493                     "command": "rust-analyzer.viewFileText",
1494                     "when": "inRustProject"
1495                 },
1496                 {
1497                     "command": "rust-analyzer.expandMacro",
1498                     "when": "inRustProject"
1499                 },
1500                 {
1501                     "command": "rust-analyzer.matchingBrace",
1502                     "when": "inRustProject"
1503                 },
1504                 {
1505                     "command": "rust-analyzer.parentModule",
1506                     "when": "inRustProject"
1507                 },
1508                 {
1509                     "command": "rust-analyzer.joinLines",
1510                     "when": "inRustProject"
1511                 },
1512                 {
1513                     "command": "rust-analyzer.run",
1514                     "when": "inRustProject"
1515                 },
1516                 {
1517                     "command": "rust-analyzer.debug",
1518                     "when": "inRustProject"
1519                 },
1520                 {
1521                     "command": "rust-analyzer.newDebugConfig",
1522                     "when": "inRustProject"
1523                 },
1524                 {
1525                     "command": "rust-analyzer.analyzerStatus",
1526                     "when": "inRustProject"
1527                 },
1528                 {
1529                     "command": "rust-analyzer.memoryUsage",
1530                     "when": "inRustProject"
1531                 },
1532                 {
1533                     "command": "rust-analyzer.reloadWorkspace",
1534                     "when": "inRustProject"
1535                 },
1536                 {
1537                     "command": "rust-analyzer.reload",
1538                     "when": "inRustProject"
1539                 },
1540                 {
1541                     "command": "rust-analyzer.onEnter",
1542                     "when": "inRustProject"
1543                 },
1544                 {
1545                     "command": "rust-analyzer.ssr",
1546                     "when": "inRustProject"
1547                 },
1548                 {
1549                     "command": "rust-analyzer.serverVersion",
1550                     "when": "inRustProject"
1551                 },
1552                 {
1553                     "command": "rust-analyzer.toggleInlayHints",
1554                     "when": "inRustProject"
1555                 },
1556                 {
1557                     "command": "rust-analyzer.openDocs",
1558                     "when": "inRustProject"
1559                 },
1560                 {
1561                     "command": "rust-analyzer.openCargoToml",
1562                     "when": "inRustProject"
1563                 }
1564             ],
1565             "editor/context": [
1566                 {
1567                     "command": "rust-analyzer.peekTests",
1568                     "when": "inRustProject",
1569                     "group": "navigation@1000"
1570                 }
1571             ]
1572         }
1573     }
1574 }