editors/code/package.json

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