mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
c8ace3a295
rust/editors/code/package.json

1102 lines
45 KiB
JSON
Raw Normal View History

JS plugin
2018-07-30 13:58:49 -05:00
{
Rename VS Code extension to rust-analyzer
2020-01-08 10:21:18 -06:00
"name": "rust-analyzer",
"displayName": "rust-analyzer",
Run npm update and add private and preview flags Private stops npm publish working, which would be nonsensical anyway In case it gets added to the vscode extension repository, preview marks it as such Private may also prevent publishing to the vscode extension repository
2018-12-08 14:56:31 -06:00
"description": "An alternative rust language server to the RLS",
"preview": true,
"private": true,
Rename VS Code extension to rust-analyzer
2020-01-08 10:21:18 -06:00
"icon": "icon.png",
Simplify extension tag sniffing
2020-03-19 03:32:57 -05:00
"version": "0.4.0-dev",
Make from-source install use cargo installed binary by default
2020-03-20 06:50:50 -05:00
"releaseTag": null,
you better run
2018-08-27 14:52:43 -05:00
"publisher": "matklad",
"repository": {
fix repo link in package.json
2020-02-02 04:16:41 -06:00
"url": "https://github.com/rust-analyzer/rust-analyzer.git",
"type": "git"
you better run
2018-08-27 14:52:43 -05:00
},
Minimal viable meta
2020-03-02 07:27:26 -06:00
"homepage": "https://rust-analyzer.github.io/",
"license": "MIT OR Apache-2.0",
"keywords": [
"rust"
],
you better run
2018-08-27 14:52:43 -05:00
"categories": [
Minimal viable meta
2020-03-02 07:27:26 -06:00
"Programming Languages"
reorganize
2018-08-10 17:04:09 -05:00
],
you better run
2018-08-27 14:52:43 -05:00
"engines": {
LSP 3.16 - Released
2020-12-08 19:56:43 -06:00
"vscode": "^1.52.0"
you better run
2018-08-27 14:52:43 -05:00
},
Enable SemanticTokens on the client This will crash the extension on stable and insiders without the "--enable-proposed-api matklad.rust-analyzer" command line switch.
2020-02-26 07:42:26 -06:00
"enableProposedApi": true,
you better run
2018-08-27 14:52:43 -05:00
"scripts": {
Remove unnecessary flags
2020-02-03 11:03:36 -06:00
"vscode:prepublish": "tsc && rollup -c",
Fix extension name
2020-02-17 08:33:31 -06:00
"package": "vsce package -o rust-analyzer.vsix",
Build extension too
2020-04-28 15:32:23 -05:00
"build": "tsc",
Remove unnecessary flags
2020-02-03 11:03:36 -06:00
"watch": "tsc --watch",
vscode client side tests
2020-05-20 13:03:49 -05:00
"lint": "tsfmt --verify && eslint -c .eslintrc.js --ext ts ./src ./tests",
"fix": " tsfmt -r && eslint -c .eslintrc.js --ext ts ./src ./tests --fix",
"pretest": "npm run build",
"test": "node ./out/tests/runTests.js"
you better run
2018-08-27 14:52:43 -05:00
},
"dependencies": {
Bump node-fetch from 2.6.0 to 2.6.1 in /editors/code Bumps [node-fetch](https://github.com/bitinn/node-fetch) from 2.6.0 to 2.6.1. - [Release notes](https://github.com/bitinn/node-fetch/releases) - [Changelog](https://github.com/node-fetch/node-fetch/blob/master/docs/CHANGELOG.md) - [Commits](https://github.com/bitinn/node-fetch/compare/v2.6.0...v2.6.1) Signed-off-by: dependabot[bot] <support@github.com>
2020-09-12 09:50:54 -05:00
"node-fetch": "^2.6.1",
LSP 3.16 - Released
2020-12-08 19:56:43 -06:00
"vscode-languageclient": "7.0.0"
you better run
2018-08-27 14:52:43 -05:00
},
"devDependencies": {
Update npm packages
2020-12-07 11:12:40 -06:00
"@rollup/plugin-commonjs": "^17.0.0",
"@rollup/plugin-node-resolve": "^11.0.0",
Update the rest of our node packages
2020-09-01 13:22:44 -05:00
"@types/glob": "^7.1.3",
Update npm packages
2020-12-07 11:12:40 -06:00
"@types/mocha": "^8.0.4",
"@types/node": "~12.12.6",
Bump packages
2020-05-12 16:43:47 -05:00
"@types/node-fetch": "^2.5.7",
LSP 3.16 - Released
2020-12-08 19:56:43 -06:00
"@types/vscode": "^1.52.0",
Update npm packages
2020-12-07 11:12:40 -06:00
"@typescript-eslint/eslint-plugin": "^4.9.0",
"@typescript-eslint/parser": "^4.9.0",
"eslint": "^7.15.0",
vscode client side tests
2020-05-20 13:03:49 -05:00
"glob": "^7.1.6",
Update npm packages
2020-12-07 11:12:40 -06:00
"mocha": "^8.2.1",
"rollup": "^2.34.2",
"tslib": "^2.0.3",
"typescript": "^4.1.2",
added fetchLatestArtifactMetadata() and downloadFile() functions
2020-02-06 19:11:24 -06:00
"typescript-formatter": "^7.2.2",
Update npm packages
2020-12-07 11:12:40 -06:00
"vsce": "^1.81.1",
"vscode-test": "^1.4.1"
Add prettier
2019-12-30 08:08:38 -06:00
},
you better run
2018-08-27 14:52:43 -05:00
"activationEvents": [
Start the extension when rust-analyzer status is run
2019-01-29 11:08:02 -06:00
"onLanguage:rust",
"onCommand:rust-analyzer.analyzerStatus",
Add a command to compute memory usage statistics
2020-07-07 05:10:14 -05:00
"onCommand:rust-analyzer.memoryUsage",
Add reload workspace command
2020-07-01 07:57:59 -05:00
"onCommand:rust-analyzer.reloadWorkspace",
activate extension if Cargo.toml is present
2019-03-13 08:14:30 -05:00
"workspaceContains:**/Cargo.toml"
indexing infra
2018-08-13 05:46:05 -05:00
],
vscode client side tests
2020-05-20 13:03:49 -05:00
"main": "./out/src/main",
you better run
2018-08-27 14:52:43 -05:00
"contributes": {
"taskDefinitions": [
{
"type": "cargo",
"required": [
"command"
],
"properties": {
"label": {
"type": "string"
},
"command": {
"type": "string"
},
"args": {
vscode: more type safety
2020-03-23 18:11:36 -05:00
"type": "array",
"items": {
"type": "string"
}
you better run
2018-08-27 14:52:43 -05:00
},
"env": {
vscode: more type safety
2020-03-23 18:11:36 -05:00
"type": "object",
"patternProperties": {
".+": {
"type": "string"
}
}
you better run
2018-08-27 14:52:43 -05:00
}
}
}
],
"commands": [
{
align command naming
2019-01-28 05:43:07 -06:00
"command": "rust-analyzer.syntaxTree",
Add vscode support for range in SyntaxTreeParams This enables the client to use a command to either show the live-updating version of the syntax tree for the current file. Or optionally when a selected range is provided, we then provide a snapshot of the syntax tree for the range.
2019-03-03 13:21:40 -06:00
"title": "Show Syntax Tree",
Add category to the commands
2019-01-29 11:16:14 -06:00
"category": "Rust Analyzer"
you better run
2018-08-27 14:52:43 -05:00
},
Initial implementation of view-hir command
2020-12-28 12:29:58 -06:00
{
"command": "rust-analyzer.viewHir",
"title": "View Hir",
"category": "Rust Analyzer"
},
Use DocumentProvider instead of Hover
2019-11-19 11:06:10 -06:00
{
"command": "rust-analyzer.expandMacro",
"title": "Expand macro recursively",
"category": "Rust Analyzer"
},
you better run
2018-08-27 14:52:43 -05:00
{
align command naming
2019-01-28 05:43:07 -06:00
"command": "rust-analyzer.matchingBrace",
Add category to the commands
2019-01-29 11:16:14 -06:00
"title": "Find matching brace",
"category": "Rust Analyzer"
you better run
2018-08-27 14:52:43 -05:00
},
{
align command naming
2019-01-28 05:43:07 -06:00
"command": "rust-analyzer.parentModule",
Add category to the commands
2019-01-29 11:16:14 -06:00
"title": "Locate parent module",
"category": "Rust Analyzer"
you better run
2018-08-27 14:52:43 -05:00
},
{
align command naming
2019-01-28 05:43:07 -06:00
"command": "rust-analyzer.joinLines",
Add category to the commands
2019-01-29 11:16:14 -06:00
"title": "Join lines",
"category": "Rust Analyzer"
you better run
2018-08-27 14:52:43 -05:00
},
{
align command naming
2019-01-28 05:43:07 -06:00
"command": "rust-analyzer.run",
Add category to the commands
2019-01-29 11:16:14 -06:00
"title": "Run",
"category": "Rust Analyzer"
ad status command
2019-01-22 15:15:03 -06:00
},
"rust-analyzer.debug" command
2020-05-11 08:06:57 -05:00
{
"command": "rust-analyzer.debug",
"title": "Debug",
"category": "Rust Analyzer"
},
"rust-analyzer.newDebugConfig" command
2020-05-11 10:00:15 -05:00
{
"command": "rust-analyzer.newDebugConfig",
"title": "Generate launch configuration",
"category": "Rust Analyzer"
},
ad status command
2019-01-22 15:15:03 -06:00
{
align command naming
2019-01-28 05:43:07 -06:00
"command": "rust-analyzer.analyzerStatus",
Add category to the commands
2019-01-29 11:16:14 -06:00
"title": "Status",
"category": "Rust Analyzer"
add gc request
2019-01-25 10:11:58 -06:00
},
Add a command to compute memory usage statistics
2020-07-07 05:10:14 -05:00
{
"command": "rust-analyzer.memoryUsage",
"title": "Memory Usage (Clears Database)",
"category": "Rust Analyzer"
},
add gc request
2019-01-25 10:11:58 -06:00
{
Add reload workspace command
2020-07-01 07:57:59 -05:00
"command": "rust-analyzer.reloadWorkspace",
"title": "Reload workspace",
Add category to the commands
2019-01-29 11:16:14 -06:00
"category": "Rust Analyzer"
Adds "restart server" command
2019-04-15 14:41:27 -05:00
},
{
"command": "rust-analyzer.reload",
"title": "Restart server",
"category": "Rust Analyzer"
Add regular onEnter command, allowing onEnter to be called without overriding the type command.
2020-02-01 19:21:04 -06:00
},
Add a command for updating the Github API token
2020-09-23 02:50:34 -05:00
{
"command": "rust-analyzer.updateGithubToken",
"title": "Update Github API token",
"category": "Rust Analyzer"
},
Add regular onEnter command, allowing onEnter to be called without overriding the type command.
2020-02-01 19:21:04 -06:00
{
"command": "rust-analyzer.onEnter",
"title": "Enhanced enter key",
"category": "Rust Analyzer"
Init implementation of structural search replace
2020-02-10 16:45:38 -06:00
},
{
"command": "rust-analyzer.ssr",
"title": "Structural Search Replace",
"category": "Rust Analyzer"
Improve server version info
2020-02-20 20:04:03 -06:00
},
{
"command": "rust-analyzer.serverVersion",
"title": "Show RA Version",
"category": "Rust Analyzer"
Introduce `toggle inlay hints` vscode command Users now can assign a shortcut for this command via the general vscode keybindings ui or `keybinding.json file` Closes: #4599
2020-05-24 19:47:33 -05:00
},
{
"command": "rust-analyzer.toggleInlayHints",
"title": "Toggle inlay hints",
"category": "Rust Analyzer"
WIP: Command to open docs under cursor
2020-08-30 03:02:29 -05:00
},
{
"command": "rust-analyzer.openDocs",
"title": "Open docs under cursor",
"category": "Rust Analyzer"
add open Cargo.toml action
2020-11-12 19:48:07 -06:00
},
{
"command": "rust-analyzer.openCargoToml",
"title": "Open Cargo.toml",
"category": "Rust Analyzer"
you better run
2018-08-27 14:52:43 -05:00
}
],
"keybindings": [
{
align command naming
2019-01-28 05:43:07 -06:00
"command": "rust-analyzer.parentModule",
Fix parentModule shortcut conflict The default parentModule shortcut conflicts with VSCode's built-in undo selection
2020-04-13 05:13:55 -05:00
"key": "ctrl+shift+u",
you better run
2018-08-27 14:52:43 -05:00
"when": "editorTextFocus && editorLangId == rust"
},
{
align command naming
2019-01-28 05:43:07 -06:00
"command": "rust-analyzer.matchingBrace",
you better run
2018-08-27 14:52:43 -05:00
"key": "ctrl+shift+m",
"when": "editorTextFocus && editorLangId == rust"
},
{
align command naming
2019-01-28 05:43:07 -06:00
"command": "rust-analyzer.joinLines",
you better run
2018-08-27 14:52:43 -05:00
"key": "ctrl+shift+j",
"when": "editorTextFocus && editorLangId == rust"
}
indexing infra
2018-08-13 05:46:05 -05:00
],
Add a setting to disable custom syntax highlighting
2018-09-29 14:27:41 -05:00
"configuration": {
"type": "object",
Dynamically apply highlightingOn config Fixes #84
2018-10-06 15:53:12 -05:00
"title": "Rust Analyzer",
Add a setting to disable custom syntax highlighting
2018-09-29 14:27:41 -05:00
"properties": {
Add custom cargo runners
2020-06-18 14:20:13 -05:00
"rust-analyzer.cargoRunner": {
"type": [
"null",
"string"
],
"default": null,
"description": "Custom cargo runner extension ID."
},
Add runnable env support.
2020-07-02 11:47:40 -05:00
"rust-analyzer.runnableEnv": {
"anyOf": [
{
"type": "null"
},
{
"type": "array",
"items": {
"type": "object",
"properties": {
"mask": {
"type": "string",
"description": "Runnable name mask"
},
"env": {
"type": "object",
"description": "Variables in form of { \"key\": \"value\"}"
}
}
}
},
{
"type": "object",
"description": "Variables in form of { \"key\": \"value\"}"
}
],
"default": null,
Clean up descriptions for settings Use two consecutive newlines (`\n\n`) to actually continue text on a new line. Use proper markup to reference related settings. Consistently format references to files, editor commands, command line arguments, files, etc. as `code`. Fix typos, add missing full-stops, add missing default values.
2020-12-21 18:15:50 -06:00
"markdownDescription": "Environment variables passed to the runnable launched using `Test` or `Debug` lens or `rust-analyzer.run` command."
Add runnable env support.
2020-07-02 11:47:40 -05:00
},
Add master config for inlayHints to make disabling easy
2020-05-08 02:28:15 -05:00
"rust-analyzer.inlayHints.enable": {
"type": "boolean",
"default": true,
Clean up descriptions for settings Use two consecutive newlines (`\n\n`) to actually continue text on a new line. Use proper markup to reference related settings. Consistently format references to files, editor commands, command line arguments, files, etc. as `code`. Fix typos, add missing full-stops, add missing default values.
2020-12-21 18:15:50 -06:00
"description": "Whether to show inlay hints."
Add master config for inlayHints to make disabling easy
2020-05-08 02:28:15 -05:00
},
New config in package.json
2020-04-02 04:55:04 -05:00
"rust-analyzer.updates.channel": {
"type": "string",
"enum": [
"stable",
"nightly"
],
"default": "stable",
"markdownEnumDescriptions": [
Clean up descriptions for settings Use two consecutive newlines (`\n\n`) to actually continue text on a new line. Use proper markup to reference related settings. Consistently format references to files, editor commands, command line arguments, files, etc. as `code`. Fix typos, add missing full-stops, add missing default values.
2020-12-21 18:15:50 -06:00
"`stable` updates are shipped weekly, they don't contain cutting-edge features from VSCode proposed APIs but have less bugs in general.",
"`nightly` updates are shipped daily (extension updates automatically by downloading artifacts directly from GitHub), they contain cutting-edge features and latest bug fixes. These releases help us get your feedback very quickly and speed up rust-analyzer development **drastically**."
New config in package.json
2020-04-02 04:55:04 -05:00
],
Clean up descriptions for settings Use two consecutive newlines (`\n\n`) to actually continue text on a new line. Use proper markup to reference related settings. Consistently format references to files, editor commands, command line arguments, files, etc. as `code`. Fix typos, add missing full-stops, add missing default values.
2020-12-21 18:15:50 -06:00
"markdownDescription": "Choose `nightly` updates to get the latest features and bug fixes every day. While `stable` releases occur weekly and don't contain cutting-edge features from VSCode proposed APIs."
New config in package.json
2020-04-02 04:55:04 -05:00
},
"rust-analyzer.updates.askBeforeDownload": {
"type": "boolean",
"default": true,
Clean up descriptions for settings Use two consecutive newlines (`\n\n`) to actually continue text on a new line. Use proper markup to reference related settings. Consistently format references to files, editor commands, command line arguments, files, etc. as `code`. Fix typos, add missing full-stops, add missing default values.
2020-12-21 18:15:50 -06:00
"description": "Whether to ask for permission before downloading any files from the Internet."
New config in package.json
2020-04-02 04:55:04 -05:00
},
Rename extension config
2021-01-04 09:39:15 -06:00
"rust-analyzer.server.path": {
New config in package.json
2020-04-02 04:55:04 -05:00
"type": [
"null",
"string"
],
"default": null,
Clean up descriptions for settings Use two consecutive newlines (`\n\n`) to actually continue text on a new line. Use proper markup to reference related settings. Consistently format references to files, editor commands, command line arguments, files, etc. as `code`. Fix typos, add missing full-stops, add missing default values.
2020-12-21 18:15:50 -06:00
"markdownDescription": "Path to rust-analyzer executable (points to bundled binary by default). If this is set, then `#rust-analyzer.updates.channel#` setting is not used"
New config in package.json
2020-04-02 04:55:04 -05:00
},
Add an option for extra env vars in the Code extension
2020-12-30 03:17:25 -06:00
"rust-analyzer.server.extraEnv": {
"type": [
"null",
"object"
],
"default": null,
"markdownDescription": "Extra environment variables that will be passed to the rust-analyzer executable. Useful for passing e.g. `RA_LOG` for debugging."
},
New config in package.json
2020-04-02 04:55:04 -05:00
"rust-analyzer.trace.server": {
"type": "string",
"scope": "window",
"enum": [
"off",
"messages",
"verbose"
],
"enumDescriptions": [
"No traces",
"Error only",
"Full log"
],
"default": "off",
Clean up descriptions for settings Use two consecutive newlines (`\n\n`) to actually continue text on a new line. Use proper markup to reference related settings. Consistently format references to files, editor commands, command line arguments, files, etc. as `code`. Fix typos, add missing full-stops, add missing default values.
2020-12-21 18:15:50 -06:00
"description": "Trace requests to the rust-analyzer (this is usually overly verbose and not recommended for regular users)."
New config in package.json
2020-04-02 04:55:04 -05:00
},
"rust-analyzer.trace.extension": {
Clean up descriptions for settings Use two consecutive newlines (`\n\n`) to actually continue text on a new line. Use proper markup to reference related settings. Consistently format references to files, editor commands, command line arguments, files, etc. as `code`. Fix typos, add missing full-stops, add missing default values.
2020-12-21 18:15:50 -06:00
"description": "Enable logging of VS Code extensions itself.",
New config in package.json
2020-04-02 04:55:04 -05:00
"type": "boolean",
"default": false
Add config for proc_macro
2020-04-12 11:05:33 -05:00
},
Configuration settings and source maps support
2020-04-29 05:10:42 -05:00
"rust-analyzer.debug.engine": {
better configuration enum items
2020-04-29 06:13:57 -05:00
"type": "string",
Configuration settings and source maps support
2020-04-29 05:10:42 -05:00
"enum": [
better configuration enum items
2020-04-29 06:13:57 -05:00
"auto",
"vadimcn.vscode-lldb",
"ms-vscode.cpptools"
Configuration settings and source maps support
2020-04-29 05:10:42 -05:00
],
better configuration enum items
2020-04-29 06:13:57 -05:00
"default": "auto",
package.json: Minor configuration spelling fix
2020-05-06 10:22:24 -05:00
"description": "Preferred debug engine.",
better configuration enum items
2020-04-29 06:13:57 -05:00
"markdownEnumDescriptions": [
pass Cargo errors to the Debug output channel
2020-04-30 07:25:04 -05:00
"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).",
better configuration enum items
2020-04-29 06:13:57 -05:00
"Use [CodeLLDB](https://marketplace.visualstudio.com/items?itemName=vadimcn.vscode-lldb)",
"Use [MS C++ tools](https://marketplace.visualstudio.com/items?itemName=ms-vscode.cpptools)"
]
Configuration settings and source maps support
2020-04-29 05:10:42 -05:00
},
better configuration enum items
2020-04-29 06:13:57 -05:00
"rust-analyzer.debug.sourceFileMap": {
"type": "object",
Configuration settings and source maps support
2020-04-29 05:10:42 -05:00
"description": "Optional source file mappings passed to the debug engine.",
"default": {
better configuration enum items
2020-04-29 06:13:57 -05:00
"/rustc/<id>": "${env:USERPROFILE}/.rustup/toolchains/<toolchain-id>/lib/rustlib/src/rust"
Configuration settings and source maps support
2020-04-29 05:10:42 -05:00
}
Add additional debug options
2020-05-07 09:07:58 -05:00
},
"rust-analyzer.debug.openDebugPane" Co-authored-by: bjorn3 <bjorn3@users.noreply.github.com>
2020-05-08 11:22:26 -05:00
"rust-analyzer.debug.openDebugPane": {
Clean up descriptions for settings Use two consecutive newlines (`\n\n`) to actually continue text on a new line. Use proper markup to reference related settings. Consistently format references to files, editor commands, command line arguments, files, etc. as `code`. Fix typos, add missing full-stops, add missing default values.
2020-12-21 18:15:50 -06:00
"markdownDescription": "Whether to open up the `Debug Panel` on debugging start.",
Add additional debug options
2020-05-07 09:07:58 -05:00
"type": "boolean",
"default": false
},
"rust-analyzer.debug.engineSettings": {
"type": "object",
"default": {},
Clean up descriptions for settings Use two consecutive newlines (`\n\n`) to actually continue text on a new line. Use proper markup to reference related settings. Consistently format references to files, editor commands, command line arguments, files, etc. as `code`. Fix typos, add missing full-stops, add missing default values.
2020-12-21 18:15:50 -06:00
"markdownDescription": "Optional settings passed to the debug engine. Example: `{ \"lldb\": { \"terminal\":\"external\"} }`"
CodeLens configuration options.
2020-05-17 11:51:44 -05:00
},
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"rust-analyzer.assist.importMergeBehaviour": {
"markdownDescription": "The strategy to use when inserting new imports or merging imports.",
"default": "full",
"type": "string",
"enum": [
"none",
"full",
"last"
],
"enumDescriptions": [
"No merging",
"Merge all layers of the import trees",
"Only merge the last layer of the import trees"
]
Add "rust-analyzer.lens.enable"
2020-05-18 02:27:00 -05:00
},
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"rust-analyzer.assist.importPrefix": {
"markdownDescription": "The path structure for newly inserted paths to use.",
"default": "plain",
"type": "string",
"enum": [
"plain",
"by_self",
"by_crate"
],
"enumDescriptions": [
"Insert import paths relative to the current module, using up to one `super` prefix if the parent module contains the requested item.",
Clean up descriptions for settings Use two consecutive newlines (`\n\n`) to actually continue text on a new line. Use proper markup to reference related settings. Consistently format references to files, editor commands, command line arguments, files, etc. as `code`. Fix typos, add missing full-stops, add missing default values.
2020-12-21 18:15:50 -06:00
"Prefix all import paths with `self` if they don't begin with `self`, `super`, `crate` or a crate name.",
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"Force import paths to be absolute by always starting them with `crate` or the crate name they refer to."
]
CodeLens configuration options.
2020-05-17 11:51:44 -05:00
},
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"rust-analyzer.callInfo.full": {
"markdownDescription": "Show function name and docs in parameter hints.",
"default": true,
"type": "boolean"
CodeLens configuration options.
2020-05-17 11:51:44 -05:00
},
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"rust-analyzer.cargo.autoreload": {
Clean up descriptions for settings Use two consecutive newlines (`\n\n`) to actually continue text on a new line. Use proper markup to reference related settings. Consistently format references to files, editor commands, command line arguments, files, etc. as `code`. Fix typos, add missing full-stops, add missing default values.
2020-12-21 18:15:50 -06:00
"markdownDescription": "Automatically refresh project info via `cargo metadata` on `Cargo.toml` changes.",
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"default": true,
"type": "boolean"
Add hover actions as LSP extension
2020-06-03 06:15:54 -05:00
},
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"rust-analyzer.cargo.allFeatures": {
"markdownDescription": "Activate all available features.",
"default": false,
"type": "boolean"
Add method references CodeLens
2020-09-01 08:33:02 -05:00
},
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"rust-analyzer.cargo.features": {
"markdownDescription": "List of features to activate.",
"default": [],
"type": "array",
"items": {
"type": "string"
}
Add hover actions as LSP extension
2020-06-03 06:15:54 -05:00
},
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"rust-analyzer.cargo.loadOutDirsFromCheck": {
"markdownDescription": "Run `cargo check` on startup to get the correct value for package OUT_DIRs.",
"default": false,
"type": "boolean"
Document rust-project.json
2020-06-03 07:48:38 -05:00
},
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"rust-analyzer.cargo.noDefaultFeatures": {
"markdownDescription": "Do not activate the `default` feature.",
"default": false,
"type": "boolean"
Add Run|Debug hover actions
2020-06-06 06:30:29 -05:00
},
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"rust-analyzer.cargo.target": {
"markdownDescription": "Compilation target (target triple).",
"default": null,
"type": [
"null",
"string"
]
Add `rust-analyzer.gotoLocation` command
2020-06-10 15:01:19 -05:00
},
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"rust-analyzer.cargo.noSysroot": {
"markdownDescription": "Internal config for debugging, disables loading of sysroot crates.",
"default": false,
"type": "boolean"
Add Run|Debug hover actions
2020-06-06 06:30:29 -05:00
},
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"rust-analyzer.checkOnSave.enable": {
"markdownDescription": "Run specified `cargo check` command for diagnostics on save.",
"default": true,
"type": "boolean"
},
"rust-analyzer.checkOnSave.allFeatures": {
Clean up descriptions for settings Use two consecutive newlines (`\n\n`) to actually continue text on a new line. Use proper markup to reference related settings. Consistently format references to files, editor commands, command line arguments, files, etc. as `code`. Fix typos, add missing full-stops, add missing default values.
2020-12-21 18:15:50 -06:00
"markdownDescription": "Check with all features (will be passed as `--all-features`). Defaults to `#rust-analyzer.cargo.allFeatures#`.",
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"default": null,
"type": [
"null",
"boolean"
]
},
"rust-analyzer.checkOnSave.allTargets": {
"markdownDescription": "Check all targets and tests (will be passed as `--all-targets`).",
"default": true,
"type": "boolean"
},
"rust-analyzer.checkOnSave.command": {
"markdownDescription": "Cargo command to use for `cargo check`.",
"default": "check",
"type": "string"
},
"rust-analyzer.checkOnSave.noDefaultFeatures": {
"markdownDescription": "Do not activate the `default` feature.",
"default": null,
"type": [
"null",
"boolean"
]
},
"rust-analyzer.checkOnSave.target": {
Clean up descriptions for settings Use two consecutive newlines (`\n\n`) to actually continue text on a new line. Use proper markup to reference related settings. Consistently format references to files, editor commands, command line arguments, files, etc. as `code`. Fix typos, add missing full-stops, add missing default values.
2020-12-21 18:15:50 -06:00
"markdownDescription": "Check for a specific target. Defaults to `#rust-analyzer.cargo.target#`.",
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"default": null,
"type": [
"null",
"string"
]
},
"rust-analyzer.checkOnSave.extraArgs": {
"markdownDescription": "Extra arguments for `cargo check`.",
"default": [],
Document rust-project.json
2020-06-03 07:48:38 -05:00
"type": "array",
"items": {
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"type": "string"
}
},
"rust-analyzer.checkOnSave.features": {
Clean up descriptions for settings Use two consecutive newlines (`\n\n`) to actually continue text on a new line. Use proper markup to reference related settings. Consistently format references to files, editor commands, command line arguments, files, etc. as `code`. Fix typos, add missing full-stops, add missing default values.
2020-12-21 18:15:50 -06:00
"markdownDescription": "List of features to activate. Defaults to `#rust-analyzer.cargo.features#`.",
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"default": null,
"type": [
"null",
"array"
],
"items": {
"type": "string"
}
},
"rust-analyzer.checkOnSave.overrideCommand": {
"markdownDescription": "Advanced option, fully override the command rust-analyzer uses for checking. The command should include `--message-format=json` or similar option.",
"default": null,
"type": [
"null",
"array"
],
"items": {
"type": "string"
}
},
"rust-analyzer.completion.addCallArgumentSnippets": {
"markdownDescription": "Whether to add argument snippets when completing functions.",
"default": true,
"type": "boolean"
},
"rust-analyzer.completion.addCallParenthesis": {
"markdownDescription": "Whether to add parenthesis when completing functions.",
"default": true,
"type": "boolean"
},
"rust-analyzer.completion.postfix.enable": {
"markdownDescription": "Whether to show postfix snippets like `dbg`, `if`, `not`, etc.",
"default": true,
"type": "boolean"
},
"rust-analyzer.completion.autoimport.enable": {
Clean up descriptions for settings Use two consecutive newlines (`\n\n`) to actually continue text on a new line. Use proper markup to reference related settings. Consistently format references to files, editor commands, command line arguments, files, etc. as `code`. Fix typos, add missing full-stops, add missing default values.
2020-12-21 18:15:50 -06:00
"markdownDescription": "Toggles the additional completions that automatically add imports when completed. Note that your client must specify the `additionalTextEdits` LSP client capability to truly have this feature enabled.",
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"default": true,
"type": "boolean"
Document rust-project.json
2020-06-03 07:48:38 -05:00
},
Add toggle for experimental diagnostics
2020-07-24 10:39:16 -05:00
"rust-analyzer.diagnostics.enable": {
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"markdownDescription": "Whether to show native rust-analyzer diagnostics.",
Add toggle for experimental diagnostics
2020-07-24 10:39:16 -05:00
"default": true,
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"type": "boolean"
Add toggle for experimental diagnostics
2020-07-24 10:39:16 -05:00
},
"rust-analyzer.diagnostics.enableExperimental": {
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"markdownDescription": "Whether to show experimental rust-analyzer diagnostics that might have more false positives than usual.",
Add toggle for experimental diagnostics
2020-07-24 10:39:16 -05:00
"default": true,
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"type": "boolean"
Add toggle for experimental diagnostics
2020-07-24 10:39:16 -05:00
},
Align diagnostics config with the rest of rust-analyzer
2020-08-18 09:03:15 -05:00
"rust-analyzer.diagnostics.disabled": {
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"markdownDescription": "List of rust-analyzer diagnostics to disable.",
"default": [],
Warnings as hint or info
2020-06-16 15:26:33 -05:00
"type": "array",
"items": {
"type": "string"
},
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"uniqueItems": true
Warnings as hint or info
2020-06-16 15:26:33 -05:00
},
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"rust-analyzer.diagnostics.warningsAsHint": {
Clean up descriptions for settings Use two consecutive newlines (`\n\n`) to actually continue text on a new line. Use proper markup to reference related settings. Consistently format references to files, editor commands, command line arguments, files, etc. as `code`. Fix typos, add missing full-stops, add missing default values.
2020-12-21 18:15:50 -06:00
"markdownDescription": "List of warnings that should be displayed with info severity.\\n\\nThe warnings will be indicated by a blue squiggly underline in code and a blue icon in the `Problems Panel`.",
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"default": [],
Warnings as hint or info
2020-06-16 15:26:33 -05:00
"type": "array",
"items": {
"type": "string"
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
}
Add a configuration option for the vscode extension
2020-08-12 08:06:55 -05:00
},
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"rust-analyzer.diagnostics.warningsAsInfo": {
Clean up descriptions for settings Use two consecutive newlines (`\n\n`) to actually continue text on a new line. Use proper markup to reference related settings. Consistently format references to files, editor commands, command line arguments, files, etc. as `code`. Fix typos, add missing full-stops, add missing default values.
2020-12-21 18:15:50 -06:00
"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 and will not show up in the `Problems Panel`.",
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"default": [],
Add a configuration option for the vscode extension
2020-08-12 08:06:55 -05:00
"type": "array",
"items": {
"type": "string"
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
}
Make MergeBehaviour configurable
2020-09-12 04:55:01 -05:00
},
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"rust-analyzer.files.watcher": {
"markdownDescription": "Controls file watching implementation.",
"default": "client",
"type": "string"
Support 'runnables' options in the vs code extension
2020-09-05 08:21:14 -05:00
},
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"rust-analyzer.hoverActions.debug": {
"markdownDescription": "Whether to show `Debug` action. Only applies when `#rust-analyzer.hoverActions.enable#` is set.",
"default": true,
"type": "boolean"
},
"rust-analyzer.hoverActions.enable": {
"markdownDescription": "Whether to show HoverActions in Rust files.",
"default": true,
"type": "boolean"
},
"rust-analyzer.hoverActions.gotoTypeDef": {
"markdownDescription": "Whether to show `Go to Type Definition` action. Only applies when `#rust-analyzer.hoverActions.enable#` is set.",
"default": true,
"type": "boolean"
},
"rust-analyzer.hoverActions.implementations": {
"markdownDescription": "Whether to show `Implementations` action. Only applies when `#rust-analyzer.hoverActions.enable#` is set.",
"default": true,
"type": "boolean"
},
"rust-analyzer.hoverActions.run": {
"markdownDescription": "Whether to show `Run` action. Only applies when `#rust-analyzer.hoverActions.enable#` is set.",
"default": true,
"type": "boolean"
},
"rust-analyzer.hoverActions.linksInHover": {
"markdownDescription": "Use markdown syntax for links in hover.",
"default": true,
"type": "boolean"
},
"rust-analyzer.inlayHints.chainingHints": {
"markdownDescription": "Whether to show inlay type hints for method chains.",
"default": true,
"type": "boolean"
},
"rust-analyzer.inlayHints.maxLength": {
Clean up descriptions for settings Use two consecutive newlines (`\n\n`) to actually continue text on a new line. Use proper markup to reference related settings. Consistently format references to files, editor commands, command line arguments, files, etc. as `code`. Fix typos, add missing full-stops, add missing default values.
2020-12-21 18:15:50 -06:00
"markdownDescription": "Maximum length for inlay hints. Default is unlimited.",
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"default": null,
"type": [
"null",
"integer"
Make ImportPrefix a configuration option
2020-10-05 10:41:49 -05:00
],
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"minimum": 0
},
"rust-analyzer.inlayHints.parameterHints": {
"markdownDescription": "Whether to show function parameter name inlay hints at the call site.",
"default": true,
"type": "boolean"
},
"rust-analyzer.inlayHints.typeHints": {
"markdownDescription": "Whether to show inlay type hints for variables.",
"default": true,
"type": "boolean"
},
"rust-analyzer.lens.debug": {
"markdownDescription": "Whether to show `Debug` lens. Only applies when `#rust-analyzer.lens.enable#` is set.",
"default": true,
"type": "boolean"
},
"rust-analyzer.lens.enable": {
"markdownDescription": "Whether to show CodeLens in Rust files.",
"default": true,
"type": "boolean"
},
"rust-analyzer.lens.implementations": {
"markdownDescription": "Whether to show `Implementations` lens. Only applies when `#rust-analyzer.lens.enable#` is set.",
"default": true,
"type": "boolean"
},
"rust-analyzer.lens.run": {
"markdownDescription": "Whether to show `Run` lens. Only applies when `#rust-analyzer.lens.enable#` is set.",
"default": true,
"type": "boolean"
},
"rust-analyzer.lens.methodReferences": {
"markdownDescription": "Whether to show `Method References` lens. Only applies when `#rust-analyzer.lens.enable#` is set.",
"default": false,
"type": "boolean"
},
"rust-analyzer.linkedProjects": {
Clean up descriptions for settings Use two consecutive newlines (`\n\n`) to actually continue text on a new line. Use proper markup to reference related settings. Consistently format references to files, editor commands, command line arguments, files, etc. as `code`. Fix typos, add missing full-stops, add missing default values.
2020-12-21 18:15:50 -06:00
"markdownDescription": "Disable project auto-discovery in favor of explicitly specified set of projects.\\n\\nElements must be paths pointing to `Cargo.toml`, `rust-project.json`, or JSON objects in `rust-project.json` format.",
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"default": [],
"type": "array",
"items": {
"type": [
"string",
"object"
]
}
},
"rust-analyzer.lruCapacity": {
Clean up descriptions for settings Use two consecutive newlines (`\n\n`) to actually continue text on a new line. Use proper markup to reference related settings. Consistently format references to files, editor commands, command line arguments, files, etc. as `code`. Fix typos, add missing full-stops, add missing default values.
2020-12-21 18:15:50 -06:00
"markdownDescription": "Number of syntax trees rust-analyzer keeps in memory. Defaults to 128.",
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"default": null,
"type": [
"null",
"integer"
Make ImportPrefix a configuration option
2020-10-05 10:41:49 -05:00
],
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"minimum": 0
},
"rust-analyzer.notifications.cargoTomlNotFound": {
"markdownDescription": "Whether to show `can't find Cargo.toml` error message.",
"default": true,
"type": "boolean"
},
"rust-analyzer.procMacro.enable": {
Clean up descriptions for settings Use two consecutive newlines (`\n\n`) to actually continue text on a new line. Use proper markup to reference related settings. Consistently format references to files, editor commands, command line arguments, files, etc. as `code`. Fix typos, add missing full-stops, add missing default values.
2020-12-21 18:15:50 -06:00
"markdownDescription": "Enable Proc macro support, `#rust-analyzer.cargo.loadOutDirsFromCheck#` must be enabled.",
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"default": false,
"type": "boolean"
Make ImportPrefix a configuration option
2020-10-05 10:41:49 -05:00
},
More maintainable config Rather than eagerly converting JSON, we losslessly keep it as is, and change the shape of user-submitted data at the last moment. This also allows us to remove a bunch of wrong Defaults
2021-01-06 04:54:28 -06:00
"rust-analyzer.procMacro.server": {
"markdownDescription": "Internal config, path to proc-macro server executable (typically, this is rust-analyzer itself, but we override this in tests).",
"default": null,
"type": [
"null",
"string"
]
},
Support 'runnables' options in the vs code extension
2020-09-05 08:21:14 -05:00
"rust-analyzer.runnables.overrideCargo": {
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"markdownDescription": "Command to be executed instead of 'cargo' for runnables.",
"default": null,
Support 'runnables' options in the vs code extension
2020-09-05 08:21:14 -05:00
"type": [
"null",
"string"
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
]
Support 'runnables' options in the vs code extension
2020-09-05 08:21:14 -05:00
},
"rust-analyzer.runnables.cargoExtraArgs": {
Clean up descriptions for settings Use two consecutive newlines (`\n\n`) to actually continue text on a new line. Use proper markup to reference related settings. Consistently format references to files, editor commands, command line arguments, files, etc. as `code`. Fix typos, add missing full-stops, add missing default values.
2020-12-21 18:15:50 -06:00
"markdownDescription": "Additional arguments to be passed to cargo for runnables such as tests or binaries.\\nFor example, it may be `--release`.",
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"default": [],
Support 'runnables' options in the vs code extension
2020-09-05 08:21:14 -05:00
"type": "array",
"items": {
"type": "string"
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
}
Add support for loading rustc private crates
2020-11-10 14:50:05 -06:00
},
Address review comments
2020-11-12 11:46:47 -06:00
"rust-analyzer.rustcSource": {
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"markdownDescription": "Path to the rust compiler sources, for usage in rustc_private projects.",
"default": null,
Address review comments
2020-11-12 11:46:47 -06:00
"type": [
"null",
"string"
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
]
},
"rust-analyzer.rustfmt.extraArgs": {
Clean up descriptions for settings Use two consecutive newlines (`\n\n`) to actually continue text on a new line. Use proper markup to reference related settings. Consistently format references to files, editor commands, command line arguments, files, etc. as `code`. Fix typos, add missing full-stops, add missing default values.
2020-12-21 18:15:50 -06:00
"markdownDescription": "Additional arguments to `rustfmt`.",
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"default": [],
"type": "array",
"items": {
"type": "string"
}
},
"rust-analyzer.rustfmt.overrideCommand": {
"markdownDescription": "Advanced option, fully override the command rust-analyzer uses for formatting.",
Add support for loading rustc private crates
2020-11-10 14:50:05 -06:00
"default": null,
Make config.rs a single source of truth for configuration. Configuration is editor-independent. For this reason, we pick JSON-schema as the repr of the source of truth. We do specify it using rust-macros and some quick&dirty hackery though. The idea for syncing truth with package.json is to just do that manually, but there's a test to check that they are actually synced. There's CLI to print config's json schema: $ rust-analyzer --print-config-schema We go with a CLI rather than LSP request/response to make it easier to incorporate the thing into extension's static config. This is roughtly how we put the thing in package.json.
2020-12-02 08:31:24 -06:00
"type": [
"null",
"array"
],
"items": {
"type": "string"
}
Lean onto default implementation of configs
2020-04-02 05:47:58 -05:00
}
Add a setting to disable custom syntax highlighting
2018-09-29 14:27:41 -05:00
}
},
fix regex and add rustc-watch problem matcher
2018-12-30 11:24:07 -06:00
"problemPatterns": [
you better run
2018-08-27 14:52:43 -05:00
{
"name": "rustc",
fix regex and add rustc-watch problem matcher
2018-12-30 11:24:07 -06:00
"patterns": [
you better run
2018-08-27 14:52:43 -05:00
{
fix regex and add rustc-watch problem matcher
2018-12-30 11:24:07 -06:00
"regexp": "^(warning|warn|error)(?:\\[(.*?)\\])?: (.*)$",
you better run
2018-08-27 14:52:43 -05:00
"severity": 1,
fix regex and add rustc-watch problem matcher
2018-12-30 11:24:07 -06:00
"code": 2,
"message": 3
you better run
2018-08-27 14:52:43 -05:00
},
{
fix regex and add rustc-watch problem matcher
2018-12-30 11:24:07 -06:00
"regexp": "^[\\s->=]*(.*?):(\\d*):(\\d*)\\s*$",
"file": 1,
"line": 2,
"column": 3
you better run
2018-08-27 14:52:43 -05:00
}
]
Add a rudimentary json regex to get at information like `endLine`
2019-12-15 10:12:52 -06:00
},
{
"name": "rustc-json",
Properly format json
2019-12-15 10:19:41 -06:00
"patterns": [
{
"regexp": "^.*\"message\":{\"message\":\"([^\"]*).*?\"file_name\":\"([^\"]+).*?\"line_start\":(\\d+).*?\"line_end\":(\\d+).*?\"column_start\":(\\d+).*?\"column_end\":(\\d+).*}$",
"message": 1,
"file": 2,
"line": 3,
"endLine": 4,
"column": 5,
"endColumn": 6
}
]
you better run
2018-08-27 14:52:43 -05:00
}
fix regex and add rustc-watch problem matcher
2018-12-30 11:24:07 -06:00
],
vscode: add highlighting of syntax tree
2020-04-01 21:38:52 -05:00
"languages": [
{
"id": "ra_syntax_tree",
"extensions": [
".rast"
]
add a language configuration for VS Code
2020-12-11 18:31:00 -06:00
},
{
"id": "rust",
"extensions": [
".rs"
],
"aliases": [
"Rust",
"rs"
],
"configuration": "language-configuration.json"
vscode: add highlighting of syntax tree
2020-04-01 21:38:52 -05:00
}
],
"grammars": [
{
"language": "ra_syntax_tree",
"scopeName": "source.ra_syntax_tree",
"path": "ra_syntax_tree.tmGrammar.json"
}
],
fix regex and add rustc-watch problem matcher
2018-12-30 11:24:07 -06:00
"problemMatchers": [
{
"name": "rustc",
ProblemMatcher auto detects relative/absolute paths and matches VSCode LSP's owner and source. VSCode LSP updated to specify owner.
2020-07-23 00:32:54 -05:00
"owner": "rustc",
"source": "rustc",
fix regex and add rustc-watch problem matcher
2018-12-30 11:24:07 -06:00
"fileLocation": [
ProblemMatcher auto detects relative/absolute paths and matches VSCode LSP's owner and source. VSCode LSP updated to specify owner.
2020-07-23 00:32:54 -05:00
"autoDetect",
fix regex and add rustc-watch problem matcher
2018-12-30 11:24:07 -06:00
"${workspaceRoot}"
],
Use named multiline Problem Matcher Now that https://github.com/Microsoft/vscode/pull/65840 is in the latest release we can use the first commit from https://github.com/rust-analyzer/rust-analyzer/pull/408
2019-02-18 12:12:54 -06:00
"pattern": "$rustc"
recover rustc-watch problemMatchers
2019-04-14 05:45:36 -05:00
},
Add a rudimentary json regex to get at information like `endLine`
2019-12-15 10:12:52 -06:00
{
"name": "rustc-json",
ProblemMatcher auto detects relative/absolute paths and matches VSCode LSP's owner and source. VSCode LSP updated to specify owner.
2020-07-23 00:32:54 -05:00
"owner": "rustc",
"source": "rustc",
Add a rudimentary json regex to get at information like `endLine`
2019-12-15 10:12:52 -06:00
"fileLocation": [
ProblemMatcher auto detects relative/absolute paths and matches VSCode LSP's owner and source. VSCode LSP updated to specify owner.
2020-07-23 00:32:54 -05:00
"autoDetect",
Add a rudimentary json regex to get at information like `endLine`
2019-12-15 10:12:52 -06:00
"${workspaceRoot}"
],
"pattern": "$rustc-json"
},
recover rustc-watch problemMatchers
2019-04-14 05:45:36 -05:00
{
"name": "rustc-watch",
ProblemMatcher auto detects relative/absolute paths and matches VSCode LSP's owner and source. VSCode LSP updated to specify owner.
2020-07-23 00:32:54 -05:00
"owner": "rustc",
"source": "rustc",
recover rustc-watch problemMatchers
2019-04-14 05:45:36 -05:00
"fileLocation": [
ProblemMatcher auto detects relative/absolute paths and matches VSCode LSP's owner and source. VSCode LSP updated to specify owner.
2020-07-23 00:32:54 -05:00
"autoDetect",
recover rustc-watch problemMatchers
2019-04-14 05:45:36 -05:00
"${workspaceRoot}"
],
"background": {
"beginsPattern": "^\\[Running\\b",
"endsPattern": "^\\[Finished running\\b"
},
"pattern": "$rustc"
fix regex and add rustc-watch problem matcher
2018-12-30 11:24:07 -06:00
}
Use ThemeColor and add support for light themes
2019-05-21 06:04:54 -05:00
],
"colors": [
{
Make inlay hints colors more configurable
2020-08-25 18:37:58 -05:00
"id": "rust_analyzer.inlayHints.foreground",
"description": "Foreground color of inlay hints (is overriden by more specific rust_analyzer.inlayHints.foreground.* configurations)",
Show type decorators
2019-07-23 08:38:21 -05:00
"defaults": {
"dark": "#A0A0A0F0",
"light": "#747474",
"highContrast": "#BEBEBE"
}
vscode: add support for light themes and color customization for syntax tree highlights
2020-04-01 17:20:08 -05:00
},
Make inlay hints colors more configurable
2020-08-25 18:37:58 -05:00
{
"id": "rust_analyzer.inlayHints.background",
"description": "Background color of inlay hints (is overriden by more specific rust_analyzer.inlayHints.background.* configurations)",
"defaults": {
"dark": "#11223300",
"light": "#11223300",
"highContrast": "#11223300"
}
},
{
"id": "rust_analyzer.inlayHints.foreground.typeHints",
"description": "Foreground color of inlay type hints for variables (overrides rust_analyzer.inlayHints.foreground)",
"defaults": {
"dark": "rust_analyzer.inlayHints.foreground",
"light": "rust_analyzer.inlayHints.foreground",
"highContrast": "rust_analyzer.inlayHints.foreground"
}
},
{
"id": "rust_analyzer.inlayHints.foreground.chainingHints",
"description": "Foreground color of inlay type hints for method chains (overrides rust_analyzer.inlayHints.foreground)",
"defaults": {
"dark": "rust_analyzer.inlayHints.foreground",
"light": "rust_analyzer.inlayHints.foreground",
"highContrast": "rust_analyzer.inlayHints.foreground"
}
},
{
"id": "rust_analyzer.inlayHints.foreground.parameterHints",
"description": "Foreground color of function parameter name inlay hints at the call site (overrides rust_analyzer.inlayHints.foreground)",
"defaults": {
"dark": "rust_analyzer.inlayHints.foreground",
"light": "rust_analyzer.inlayHints.foreground",
"highContrast": "rust_analyzer.inlayHints.foreground"
}
},
{
"id": "rust_analyzer.inlayHints.background.typeHints",
"description": "Background color of inlay type hints for variables (overrides rust_analyzer.inlayHints.background)",
"defaults": {
"dark": "rust_analyzer.inlayHints.background",
"light": "rust_analyzer.inlayHints.background",
"highContrast": "rust_analyzer.inlayHints.background"
}
},
{
"id": "rust_analyzer.inlayHints.background.chainingHints",
"description": "Background color of inlay type hints for method chains (overrides rust_analyzer.inlayHints.background)",
"defaults": {
"dark": "rust_analyzer.inlayHints.background",
"light": "rust_analyzer.inlayHints.background",
"highContrast": "rust_analyzer.inlayHints.background"
}
},
{
"id": "rust_analyzer.inlayHints.background.parameterHints",
"description": "Background color of function parameter name inlay hints at the call site (overrides rust_analyzer.inlayHints.background)",
"defaults": {
"dark": "rust_analyzer.inlayHints.background",
"light": "rust_analyzer.inlayHints.background",
"highContrast": "rust_analyzer.inlayHints.background"
}
},
vscode: add support for light themes and color customization for syntax tree highlights
2020-04-01 17:20:08 -05:00
{
"id": "rust_analyzer.syntaxTreeBorder",
"description": "Color of the border displayed in the Rust source code for the selected syntax node (see \"Show Syntax Tree\" command)",
"defaults": {
"dark": "#ffffff",
"light": "#b700ff",
"highContrast": "#b700ff"
}
Use ThemeColor and add support for light themes
2019-05-21 06:04:54 -05:00
}
wip
2020-02-26 11:20:38 -06:00
],
Better highlightign API
2020-02-26 12:39:32 -06:00
"semanticTokenTypes": [
{
Cleanup highlighting tags
2020-02-28 05:06:54 -06:00
"id": "attribute",
"description": "Style for attributes"
Color constants
2020-02-26 16:16:57 -06:00
},
Add boolean literals to package.json
2020-05-25 03:39:56 -05:00
{
"id": "boolean",
"description": "Style for boolean literals",
"superType": "keyword"
},
Color constants
2020-02-26 16:16:57 -06:00
{
Cleanup highlighting tags
2020-02-28 05:06:54 -06:00
"id": "builtinType",
Set semantic tokens supertypes
2020-04-03 05:24:11 -05:00
"description": "Style for builtin types",
"superType": "type"
Cleanup highlighting tags
2020-02-28 05:06:54 -06:00
},
{
"id": "lifetime",
"description": "Style for lifetimes"
},
{
Add self keyword semantic token type
2020-05-25 03:51:56 -05:00
"id": "selfKeyword",
"description": "Style for the self keyword",
"superType": "keyword"
},
{
Cleanup highlighting tags
2020-02-28 05:06:54 -06:00
"id": "typeAlias",
Set semantic tokens supertypes
2020-04-03 05:24:11 -05:00
"description": "Style for type aliases",
"superType": "type"
Cleanup highlighting tags
2020-02-28 05:06:54 -06:00
},
{
"id": "union",
Set semantic tokens supertypes
2020-04-03 05:24:11 -05:00
"description": "Style for C-style untagged unions",
"superType": "type"
Add semantic tag for unresolved references This is a quick way to implement unresolved reference diagnostics. For example, adding to VS Code config "editor.tokenColorCustomizationsExperimental": { "unresolvedReference": "#FF0000" }, will highlight all unresolved refs in red.
2020-04-18 13:59:22 -05:00
},
{
"id": "unresolvedReference",
"description": "Style for names which can not be resolved due to compilation errors"
Specify cotributed semanticTokenTypes in package.json
2020-05-04 06:10:59 -05:00
},
{
"id": "formatSpecifier",
"description": "Style for {} placeholders in format strings"
Better highlightign API
2020-02-26 12:39:32 -06:00
}
],
"semanticTokenModifiers": [
Color attribute functions
2020-05-12 23:58:51 -05:00
{
"id": "attribute",
"description": "Style for elements within attributes"
},
Better highlightign API
2020-02-26 12:39:32 -06:00
{
Cleanup highlighting tags
2020-02-28 05:06:54 -06:00
"id": "constant",
"description": "Style for compile-time constants"
Better highlightign API
2020-02-26 12:39:32 -06:00
},
{
Make control token modifier less ambiguous In textmate, keyword.control is used for all kinds of things; in fact, the default scope mapping for keyword is keyword.control! So let's add a less ambiguous controlFlow modifier See Microsoft/vscode#94367
2020-04-05 07:46:07 -05:00
"id": "controlFlow",
Cleanup highlighting tags
2020-02-28 05:06:54 -06:00
"description": "Style for control flow keywords"
Better highlightign API
2020-02-26 12:39:32 -06:00
},
{
Cleanup highlighting tags
2020-02-28 05:06:54 -06:00
"id": "mutable",
"description": "Style for mutable bindings"
Better highlightign API
2020-02-26 12:39:32 -06:00
},
{
Cleanup highlighting tags
2020-02-28 05:06:54 -06:00
"id": "unsafe",
"description": "Style for unsafe operations"
Document "consuming" semantic tokens modifier
2020-09-15 16:53:37 -05:00
},
{
"id": "consuming",
"description": "Style for non-Copy lvalues consumed by method/function call"
Editor: Code: Add callable to package.json
2020-10-16 07:06:52 -05:00
},
{
"id": "callable",
"description": "Style for variables/parameters that can be used in call expressions"
Better highlightign API
2020-02-26 12:39:32 -06:00
}
],
Fix semantic coloring
2020-04-02 08:52:25 -05:00
"semanticTokenScopes": [
Set attr scope
2020-02-27 11:31:54 -06:00
{
Fix semantic coloring
2020-04-02 08:52:25 -05:00
"language": "rust",
"scopes": {
"attribute": [
Use .rust suffix on scopes
2020-05-12 10:31:43 -05:00
"meta.attribute.rust"
Fix semantic coloring
2020-04-02 08:52:25 -05:00
],
Color attribute functions
2020-05-12 23:58:51 -05:00
"function.attribute": [
"entity.name.function.attribute.rust"
],
Highlight `true` and `false` as literals
2020-05-21 11:40:52 -05:00
"boolean": [
"constant.language.boolean.rust"
],
Fix semantic coloring
2020-04-02 08:52:25 -05:00
"builtinType": [
Use .rust suffix on scopes
2020-05-12 10:31:43 -05:00
"support.type.primitive.rust"
Fix semantic coloring
2020-04-02 08:52:25 -05:00
],
"lifetime": [
Change lifetimes back to keyword-ish, tweak builtins for consistency between TextMate and semantic
2020-05-10 15:32:42 -05:00
"storage.modifier.lifetime.rust"
Fix semantic coloring
2020-04-02 08:52:25 -05:00
],
"typeAlias": [
Use .rust suffix on scopes
2020-05-12 10:31:43 -05:00
"entity.name.type.typeAlias.rust"
Fix semantic coloring
2020-04-02 08:52:25 -05:00
],
"union": [
Use .rust suffix on scopes
2020-05-12 10:31:43 -05:00
"entity.name.type.union.rust"
Fix semantic coloring
2020-04-02 08:52:25 -05:00
],
Use the correct color for structs This works around https://github.com/microsoft/vscode/issues/97162
2020-05-07 11:46:58 -05:00
"struct": [
Use .rust suffix on scopes
2020-05-12 10:31:43 -05:00
"entity.name.type.struct.rust"
Use the correct color for structs This works around https://github.com/microsoft/vscode/issues/97162
2020-05-07 11:46:58 -05:00
],
Better mapping to TextMate scopes for keywords https://github.com/microsoft/vscode/issues/94367#issuecomment-608629883
2020-05-06 12:03:17 -05:00
"keyword": [
Use .rust suffix on scopes
2020-05-12 10:31:43 -05:00
"keyword.other.rust"
Better mapping to TextMate scopes for keywords https://github.com/microsoft/vscode/issues/94367#issuecomment-608629883
2020-05-06 12:03:17 -05:00
],
"keyword.controlFlow": [
Use .rust suffix on scopes
2020-05-12 10:31:43 -05:00
"keyword.control.rust"
Better mapping to TextMate scopes for keywords https://github.com/microsoft/vscode/issues/94367#issuecomment-608629883
2020-05-06 12:03:17 -05:00
],
Fix semantic coloring
2020-04-02 08:52:25 -05:00
"variable.constant": [
Use .rust suffix on scopes
2020-05-12 10:31:43 -05:00
"variable.other.constant.rust"
Tweak the textmate fallback scopes to be consistent with builtin TextMate grammar and other languages
2020-05-09 12:23:32 -05:00
],
"formatSpecifier": [
Use .rust suffix on scopes
2020-05-12 10:31:43 -05:00
"punctuation.section.embedded.rust"
Mark up statics and mutables
2020-05-09 15:19:29 -05:00
],
"*.mutable": [
"markup.underline"
Fix semantic coloring
2020-04-02 08:52:25 -05:00
]
Cleanup highlighting tags
2020-02-28 05:06:54 -06:00
}
wip
2020-02-26 11:20:38 -06:00
}
Add `inRustProject` when-clause for commands.
2020-05-27 11:40:13 -05:00
],
"menus": {
"commandPalette": [
{
"command": "rust-analyzer.syntaxTree",
"when": "inRustProject"
},
Initial implementation of view-hir command
2020-12-28 12:29:58 -06:00
{
"command": "rust-analyzer.viewHir",
"when": "inRustProject"
},
Add `inRustProject` when-clause for commands.
2020-05-27 11:40:13 -05:00
{
"command": "rust-analyzer.expandMacro",
"when": "inRustProject"
},
{
"command": "rust-analyzer.matchingBrace",
"when": "inRustProject"
},
{
"command": "rust-analyzer.parentModule",
"when": "inRustProject"
},
{
"command": "rust-analyzer.joinLines",
"when": "inRustProject"
},
{
"command": "rust-analyzer.run",
"when": "inRustProject"
},
{
"command": "rust-analyzer.debug",
"when": "inRustProject"
},
{
"command": "rust-analyzer.newDebugConfig",
"when": "inRustProject"
},
{
"command": "rust-analyzer.analyzerStatus",
"when": "inRustProject"
},
Add a command to compute memory usage statistics
2020-07-07 05:10:14 -05:00
{
"command": "rust-analyzer.memoryUsage",
"when": "inRustProject"
},
Add `inRustProject` when-clause for commands.
2020-05-27 11:40:13 -05:00
{
Add reload workspace command
2020-07-01 07:57:59 -05:00
"command": "rust-analyzer.reloadWorkspace",
Add `inRustProject` when-clause for commands.
2020-05-27 11:40:13 -05:00
"when": "inRustProject"
},
{
"command": "rust-analyzer.reload",
"when": "inRustProject"
},
Add a command for updating the Github API token
2020-09-23 02:50:34 -05:00
{
"command": "rust-analyzer.updateGithubToken",
"when": "inRustProject"
},
Add `inRustProject` when-clause for commands.
2020-05-27 11:40:13 -05:00
{
"command": "rust-analyzer.onEnter",
"when": "inRustProject"
},
{
"command": "rust-analyzer.ssr",
"when": "inRustProject"
},
{
"command": "rust-analyzer.serverVersion",
"when": "inRustProject"
},
{
"command": "rust-analyzer.toggleInlayHints",
"when": "inRustProject"
WIP: Command to open docs under cursor
2020-08-30 03:02:29 -05:00
},
{
"command": "rust-analyzer.openDocs",
"when": "inRustProject"
add open Cargo.toml action
2020-11-12 19:48:07 -06:00
},
{
"command": "rust-analyzer.openCargoToml",
"when": "inRustProject"
Add `inRustProject` when-clause for commands.
2020-05-27 11:40:13 -05:00
}
]
}
you better run
2018-08-27 14:52:43 -05:00
}
Bump chalk to use latest git to get fix * Chalk very recently (like an hour ago) merged a fix that prevents rust analyzer from panicking. This allows it to be usable again for code that hits those situations. See #6134, #6145, Probably #6120
2020-10-06 17:05:20 -05:00
}
Reference in New Issue Copy Permalink