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