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