Document not found (404)
+This URL is invalid, sorry. Please use the navigation bar or search to continue.
+ +"),i.setHtml(f),i.show(),t._signal("showGutterTooltip",i),t.on("mousewheel",c);if(e.$tooltipFollowsMouse)h(u);else{var p=u.domEvent.target,d=p.getBoundingClientRect(),v=i.getElement().style;v.left=d.right+"px",v.top=d.bottom+"px"}}function c(){o&&(o=clearTimeout(o)),f&&(i.hide(),f=null,t._signal("hideGutterTooltip",i),t.removeEventListener("mousewheel",c))}function h(e){i.setPosition(e.x,e.y)}var t=e.editor,n=t.renderer.$gutterLayer,i=new a(t.container);e.editor.setDefaultHandler("guttermousedown",function(r){if(!t.isFocused()||r.getButton()!=0)return;var i=n.getRegion(r);if(i=="foldWidgets")return;var s=r.getDocumentPosition().row,o=t.session.selection;if(r.getShiftKey())o.selectTo(s,0);else{if(r.domEvent.detail==2)return t.selectAll(),r.preventDefault();e.$clickSelection=t.selection.getLineRange(s)}return e.setState("selectByLines"),e.captureMouse(r),r.preventDefault()});var o,u,f;e.editor.setDefaultHandler("guttermousemove",function(t){var n=t.domEvent.target||t.domEvent.srcElement;if(r.hasCssClass(n,"ace_fold-widget"))return c();f&&e.$tooltipFollowsMouse&&h(t),u=t;if(o)return;o=setTimeout(function(){o=null,u&&!e.isMousePressed?l():c()},50)}),s.addListener(t.renderer.$gutter,"mouseout",function(e){u=null;if(!f||o)return;o=setTimeout(function(){o=null,c()},50)}),t.on("changeSession",c)}function a(e){o.call(this,e)}var r=e("../lib/dom"),i=e("../lib/oop"),s=e("../lib/event"),o=e("../tooltip").Tooltip;i.inherits(a,o),function(){this.setPosition=function(e,t){var n=window.innerWidth||document.documentElement.clientWidth,r=window.innerHeight||document.documentElement.clientHeight,i=this.getWidth(),s=this.getHeight();e+=15,t+=15,e+i>n&&(e-=e+i-n),t+s>r&&(t-=20+s),o.prototype.setPosition.call(this,e,t)}}.call(a.prototype),t.GutterHandler=u}),ace.define("ace/mouse/mouse_event",["require","exports","module","ace/lib/event","ace/lib/useragent"],function(e,t,n){"use strict";var r=e("../lib/event"),i=e("../lib/useragent"),s=t.MouseEvent=function(e,t){this.domEvent=e,this.editor=t,this.x=this.clientX=e.clientX,this.y=this.clientY=e.clientY,this.$pos=null,this.$inSelection=null,this.propagationStopped=!1,this.defaultPrevented=!1};(function(){this.stopPropagation=function(){r.stopPropagation(this.domEvent),this.propagationStopped=!0},this.preventDefault=function(){r.preventDefault(this.domEvent),this.defaultPrevented=!0},this.stop=function(){this.stopPropagation(),this.preventDefault()},this.getDocumentPosition=function(){return this.$pos?this.$pos:(this.$pos=this.editor.renderer.screenToTextCoordinates(this.clientX,this.clientY),this.$pos)},this.inSelection=function(){if(this.$inSelection!==null)return this.$inSelection;var e=this.editor,t=e.getSelectionRange();if(t.isEmpty())this.$inSelection=!1;else{var n=this.getDocumentPosition();this.$inSelection=t.contains(n.row,n.column)}return this.$inSelection},this.getButton=function(){return r.getButton(this.domEvent)},this.getShiftKey=function(){return this.domEvent.shiftKey},this.getAccelKey=i.isMac?function(){return this.domEvent.metaKey}:function(){return this.domEvent.ctrlKey}}).call(s.prototype)}),ace.define("ace/mouse/dragdrop_handler",["require","exports","module","ace/lib/dom","ace/lib/event","ace/lib/useragent"],function(e,t,n){"use strict";function f(e){function T(e,n){var r=Date.now(),i=!n||e.row!=n.row,s=!n||e.column!=n.column;if(!S||i||s)t.moveCursorToPosition(e),S=r,x={x:p,y:d};else{var o=l(x.x,x.y,p,d);o>a?S=null:r-S>=u&&(t.renderer.scrollCursorIntoView(),S=null)}}function N(e,n){var r=Date.now(),i=t.renderer.layerConfig.lineHeight,s=t.renderer.layerConfig.characterWidth,u=t.renderer.scroller.getBoundingClientRect(),a={x:{left:p-u.left,right:u.right-p},y:{top:d-u.top,bottom:u.bottom-d}},f=Math.min(a.x.left,a.x.right),l=Math.min(a.y.top,a.y.bottom),c={row:e.row,column:e.column};f/s<=2&&(c.column+=a.x.left
"),p.appendChild(i.createElement("div"));var m=function(e,t,n){if(t===0&&(n==="esc"||n==="return"))return h.destroy(),{command:"null"}};h.destroy=function(){if(e.$mouseHandler.isMousePressed)return;e.keyBinding.removeKeyboardHandler(m),n.widgetManager.removeLineWidget(h),e.off("changeSelection",h.destroy),e.off("changeSession",h.destroy),e.off("mouseup",h.destroy),e.off("change",h.destroy)},e.keyBinding.addKeyboardHandler(m),e.on("changeSelection",h.destroy),e.on("changeSession",h.destroy),e.on("mouseup",h.destroy),e.on("change",h.destroy),e.session.widgetManager.addLineWidget(h),h.el.onmousedown=e.focus.bind(e),e.renderer.scrollCursorIntoView(null,.5,{bottom:h.el.offsetHeight})},i.importCssString(" .error_widget_wrapper { background: inherit; color: inherit; border:none } .error_widget { border-top: solid 2px; border-bottom: solid 2px; margin: 5px 0; padding: 10px 40px; white-space: pre-wrap; } .error_widget.ace_error, .error_widget_arrow.ace_error{ border-color: #ff5a5a } .error_widget.ace_warning, .error_widget_arrow.ace_warning{ border-color: #F1D817 } .error_widget.ace_info, .error_widget_arrow.ace_info{ border-color: #5a5a5a } .error_widget.ace_ok, .error_widget_arrow.ace_ok{ border-color: #5aaa5a } .error_widget_arrow { position: absolute; border: solid 5px; border-top-color: transparent!important; border-right-color: transparent!important; border-left-color: transparent!important; top: -5px; }","")}),ace.define("ace/ace",["require","exports","module","ace/lib/fixoldbrowsers","ace/lib/dom","ace/lib/event","ace/range","ace/editor","ace/edit_session","ace/undomanager","ace/virtual_renderer","ace/worker/worker_client","ace/keyboard/hash_handler","ace/placeholder","ace/multi_select","ace/mode/folding/fold_mode","ace/theme/textmate","ace/ext/error_marker","ace/config"],function(e,t,n){"use strict";e("./lib/fixoldbrowsers");var r=e("./lib/dom"),i=e("./lib/event"),s=e("./range").Range,o=e("./editor").Editor,u=e("./edit_session").EditSession,a=e("./undomanager").UndoManager,f=e("./virtual_renderer").VirtualRenderer;e("./worker/worker_client"),e("./keyboard/hash_handler"),e("./placeholder"),e("./multi_select"),e("./mode/folding/fold_mode"),e("./theme/textmate"),e("./ext/error_marker"),t.config=e("./config"),t.require=e,typeof define=="function"&&(t.define=define),t.edit=function(e,n){if(typeof e=="string"){var s=e;e=document.getElementById(s);if(!e)throw new Error("ace.edit can't find div #"+s)}if(e&&e.env&&e.env.editor instanceof o)return e.env.editor;var u="";if(e&&/input|textarea/i.test(e.tagName)){var a=e;u=a.value,e=r.createElement("pre"),a.parentNode.replaceChild(e,a)}else e&&(u=e.textContent,e.innerHTML="");var l=t.createEditSession(u),c=new o(new f(e),l,n),h={document:l,editor:c,onResize:c.resize.bind(c,null)};return a&&(h.textarea=a),i.addListener(window,"resize",h.onResize),c.on("destroy",function(){i.removeListener(window,"resize",h.onResize),h.editor.container.env=null}),c.container.env=c.env=h,c},t.createEditSession=function(e,t){var n=new u(e,t);return n.setUndoManager(new a),n},t.Range=s,t.Editor=o,t.EditSession=u,t.UndoManager=a,t.VirtualRenderer=f,t.version="1.4.4"}); (function() { + ace.require(["ace/ace"], function(a) { + if (a) { + a.config.init(true); + a.define = ace.define; + } + if (!window.ace) + window.ace = a; + for (var key in a) if (a.hasOwnProperty(key)) + window.ace[key] = a[key]; + window.ace["default"] = window.ace; + if (typeof module == "object" && typeof exports == "object" && module) { + module.exports = window.ace; + } + }); + })(); diff --git a/docs/book/book/assists/index.html b/docs/book/book/assists/index.html new file mode 100644 index 000000000000..e32c108a4067 --- /dev/null +++ b/docs/book/book/assists/index.html @@ -0,0 +1,2409 @@ + + + + + +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/book/book/ayu-highlight.css b/docs/book/book/ayu-highlight.css
new file mode 100644
index 000000000000..32c9432224be
--- /dev/null
+++ b/docs/book/book/ayu-highlight.css
@@ -0,0 +1,78 @@
+/*
+Based off of the Ayu theme
+Original by Dempfi (https://github.com/dempfi/ayu)
+*/
+
+.hljs {
+ display: block;
+ overflow-x: auto;
+ background: #191f26;
+ color: #e6e1cf;
+}
+
+.hljs-comment,
+.hljs-quote {
+ color: #5c6773;
+ font-style: italic;
+}
+
+.hljs-variable,
+.hljs-template-variable,
+.hljs-attribute,
+.hljs-attr,
+.hljs-regexp,
+.hljs-link,
+.hljs-selector-id,
+.hljs-selector-class {
+ color: #ff7733;
+}
+
+.hljs-number,
+.hljs-meta,
+.hljs-builtin-name,
+.hljs-literal,
+.hljs-type,
+.hljs-params {
+ color: #ffee99;
+}
+
+.hljs-string,
+.hljs-bullet {
+ color: #b8cc52;
+}
+
+.hljs-title,
+.hljs-built_in,
+.hljs-section {
+ color: #ffb454;
+}
+
+.hljs-keyword,
+.hljs-selector-tag,
+.hljs-symbol {
+ color: #ff7733;
+}
+
+.hljs-name {
+ color: #36a3d9;
+}
+
+.hljs-tag {
+ color: #00568d;
+}
+
+.hljs-emphasis {
+ font-style: italic;
+}
+
+.hljs-strong {
+ font-weight: bold;
+}
+
+.hljs-addition {
+ color: #91b362;
+}
+
+.hljs-deletion {
+ color: #d96c75;
+}
diff --git a/docs/book/book/book.js b/docs/book/book/book.js
new file mode 100644
index 000000000000..ff3650eb473f
--- /dev/null
+++ b/docs/book/book/book.js
@@ -0,0 +1,688 @@
+"use strict";
+
+// Fix back button cache problem
+window.onunload = function () { };
+
+// Global variable, shared between modules
+function playground_text(playground, hidden = true) {
+ let code_block = playground.querySelector("code");
+
+ if (window.ace && code_block.classList.contains("editable")) {
+ let editor = window.ace.edit(code_block);
+ return editor.getValue();
+ } else if (hidden) {
+ return code_block.textContent;
+ } else {
+ return code_block.innerText;
+ }
+}
+
+(function codeSnippets() {
+ function fetch_with_timeout(url, options, timeout = 6000) {
+ return Promise.race([
+ fetch(url, options),
+ new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), timeout))
+ ]);
+ }
+
+ var playgrounds = Array.from(document.querySelectorAll(".playground"));
+ if (playgrounds.length > 0) {
+ fetch_with_timeout("https://play.rust-lang.org/meta/crates", {
+ headers: {
+ 'Content-Type': "application/json",
+ },
+ method: 'POST',
+ mode: 'cors',
+ })
+ .then(response => response.json())
+ .then(response => {
+ // get list of crates available in the rust playground
+ let playground_crates = response.crates.map(item => item["id"]);
+ playgrounds.forEach(block => handle_crate_list_update(block, playground_crates));
+ });
+ }
+
+ function handle_crate_list_update(playground_block, playground_crates) {
+ // update the play buttons after receiving the response
+ update_play_button(playground_block, playground_crates);
+
+ // and install on change listener to dynamically update ACE editors
+ if (window.ace) {
+ let code_block = playground_block.querySelector("code");
+ if (code_block.classList.contains("editable")) {
+ let editor = window.ace.edit(code_block);
+ editor.addEventListener("change", function (e) {
+ update_play_button(playground_block, playground_crates);
+ });
+ // add Ctrl-Enter command to execute rust code
+ editor.commands.addCommand({
+ name: "run",
+ bindKey: {
+ win: "Ctrl-Enter",
+ mac: "Ctrl-Enter"
+ },
+ exec: _editor => run_rust_code(playground_block)
+ });
+ }
+ }
+ }
+
+ // updates the visibility of play button based on `no_run` class and
+ // used crates vs ones available on https://play.rust-lang.org
+ function update_play_button(pre_block, playground_crates) {
+ var play_button = pre_block.querySelector(".play-button");
+
+ // skip if code is `no_run`
+ if (pre_block.querySelector('code').classList.contains("no_run")) {
+ play_button.classList.add("hidden");
+ return;
+ }
+
+ // get list of `extern crate`'s from snippet
+ var txt = playground_text(pre_block);
+ var re = /extern\s+crate\s+([a-zA-Z_0-9]+)\s*;/g;
+ var snippet_crates = [];
+ var item;
+ while (item = re.exec(txt)) {
+ snippet_crates.push(item[1]);
+ }
+
+ // check if all used crates are available on play.rust-lang.org
+ var all_available = snippet_crates.every(function (elem) {
+ return playground_crates.indexOf(elem) > -1;
+ });
+
+ if (all_available) {
+ play_button.classList.remove("hidden");
+ } else {
+ play_button.classList.add("hidden");
+ }
+ }
+
+ function run_rust_code(code_block) {
+ var result_block = code_block.querySelector(".result");
+ if (!result_block) {
+ result_block = document.createElement('code');
+ result_block.className = 'result hljs language-bash';
+
+ code_block.append(result_block);
+ }
+
+ let text = playground_text(code_block);
+ let classes = code_block.querySelector('code').classList;
+ let edition = "2015";
+ if(classes.contains("edition2018")) {
+ edition = "2018";
+ } else if(classes.contains("edition2021")) {
+ edition = "2021";
+ }
+ var params = {
+ version: "stable",
+ optimize: "0",
+ code: text,
+ edition: edition
+ };
+
+ if (text.indexOf("#![feature") !== -1) {
+ params.version = "nightly";
+ }
+
+ result_block.innerText = "Running...";
+
+ fetch_with_timeout("https://play.rust-lang.org/evaluate.json", {
+ headers: {
+ 'Content-Type': "application/json",
+ },
+ method: 'POST',
+ mode: 'cors',
+ body: JSON.stringify(params)
+ })
+ .then(response => response.json())
+ .then(response => {
+ if (response.result.trim() === '') {
+ result_block.innerText = "No output";
+ result_block.classList.add("result-no-output");
+ } else {
+ result_block.innerText = response.result;
+ result_block.classList.remove("result-no-output");
+ }
+ })
+ .catch(error => result_block.innerText = "Playground Communication: " + error.message);
+ }
+
+ // Syntax highlighting Configuration
+ hljs.configure({
+ tabReplace: ' ', // 4 spaces
+ languages: [], // Languages used for auto-detection
+ });
+
+ let code_nodes = Array
+ .from(document.querySelectorAll('code'))
+ // Don't highlight `inline code` blocks in headers.
+ .filter(function (node) {return !node.parentElement.classList.contains("header"); });
+
+ if (window.ace) {
+ // language-rust class needs to be removed for editable
+ // blocks or highlightjs will capture events
+ code_nodes
+ .filter(function (node) {return node.classList.contains("editable"); })
+ .forEach(function (block) { block.classList.remove('language-rust'); });
+
+ code_nodes
+ .filter(function (node) {return !node.classList.contains("editable"); })
+ .forEach(function (block) { hljs.highlightBlock(block); });
+ } else {
+ code_nodes.forEach(function (block) { hljs.highlightBlock(block); });
+ }
+
+ // Adding the hljs class gives code blocks the color css
+ // even if highlighting doesn't apply
+ code_nodes.forEach(function (block) { block.classList.add('hljs'); });
+
+ Array.from(document.querySelectorAll("code.hljs")).forEach(function (block) {
+
+ var lines = Array.from(block.querySelectorAll('.boring'));
+ // If no lines were hidden, return
+ if (!lines.length) { return; }
+ block.classList.add("hide-boring");
+
+ var buttons = document.createElement('div');
+ buttons.className = 'buttons';
+ buttons.innerHTML = "";
+
+ // add expand button
+ var pre_block = block.parentNode;
+ pre_block.insertBefore(buttons, pre_block.firstChild);
+
+ pre_block.querySelector('.buttons').addEventListener('click', function (e) {
+ if (e.target.classList.contains('fa-eye')) {
+ e.target.classList.remove('fa-eye');
+ e.target.classList.add('fa-eye-slash');
+ e.target.title = 'Hide lines';
+ e.target.setAttribute('aria-label', e.target.title);
+
+ block.classList.remove('hide-boring');
+ } else if (e.target.classList.contains('fa-eye-slash')) {
+ e.target.classList.remove('fa-eye-slash');
+ e.target.classList.add('fa-eye');
+ e.target.title = 'Show hidden lines';
+ e.target.setAttribute('aria-label', e.target.title);
+
+ block.classList.add('hide-boring');
+ }
+ });
+ });
+
+ if (window.playground_copyable) {
+ Array.from(document.querySelectorAll('pre code')).forEach(function (block) {
+ var pre_block = block.parentNode;
+ if (!pre_block.classList.contains('playground')) {
+ var buttons = pre_block.querySelector(".buttons");
+ if (!buttons) {
+ buttons = document.createElement('div');
+ buttons.className = 'buttons';
+ pre_block.insertBefore(buttons, pre_block.firstChild);
+ }
+
+ var clipButton = document.createElement('button');
+ clipButton.className = 'fa fa-copy clip-button';
+ clipButton.title = 'Copy to clipboard';
+ clipButton.setAttribute('aria-label', clipButton.title);
+ clipButton.innerHTML = '';
+
+ buttons.insertBefore(clipButton, buttons.firstChild);
+ }
+ });
+ }
+
+ // Process playground code blocks
+ Array.from(document.querySelectorAll(".playground")).forEach(function (pre_block) {
+ // Add play button
+ var buttons = pre_block.querySelector(".buttons");
+ if (!buttons) {
+ buttons = document.createElement('div');
+ buttons.className = 'buttons';
+ pre_block.insertBefore(buttons, pre_block.firstChild);
+ }
+
+ var runCodeButton = document.createElement('button');
+ runCodeButton.className = 'fa fa-play play-button';
+ runCodeButton.hidden = true;
+ runCodeButton.title = 'Run this code';
+ runCodeButton.setAttribute('aria-label', runCodeButton.title);
+
+ buttons.insertBefore(runCodeButton, buttons.firstChild);
+ runCodeButton.addEventListener('click', function (e) {
+ run_rust_code(pre_block);
+ });
+
+ if (window.playground_copyable) {
+ var copyCodeClipboardButton = document.createElement('button');
+ copyCodeClipboardButton.className = 'fa fa-copy clip-button';
+ copyCodeClipboardButton.innerHTML = '';
+ copyCodeClipboardButton.title = 'Copy to clipboard';
+ copyCodeClipboardButton.setAttribute('aria-label', copyCodeClipboardButton.title);
+
+ buttons.insertBefore(copyCodeClipboardButton, buttons.firstChild);
+ }
+
+ let code_block = pre_block.querySelector("code");
+ if (window.ace && code_block.classList.contains("editable")) {
+ var undoChangesButton = document.createElement('button');
+ undoChangesButton.className = 'fa fa-history reset-button';
+ undoChangesButton.title = 'Undo changes';
+ undoChangesButton.setAttribute('aria-label', undoChangesButton.title);
+
+ buttons.insertBefore(undoChangesButton, buttons.firstChild);
+
+ undoChangesButton.addEventListener('click', function () {
+ let editor = window.ace.edit(code_block);
+ editor.setValue(editor.originalCode);
+ editor.clearSelection();
+ });
+ }
+ });
+})();
+
+(function themes() {
+ var html = document.querySelector('html');
+ var themeToggleButton = document.getElementById('theme-toggle');
+ var themePopup = document.getElementById('theme-list');
+ var themeColorMetaTag = document.querySelector('meta[name="theme-color"]');
+ var stylesheets = {
+ ayuHighlight: document.querySelector("[href$='ayu-highlight.css']"),
+ tomorrowNight: document.querySelector("[href$='tomorrow-night.css']"),
+ highlight: document.querySelector("[href$='highlight.css']"),
+ };
+
+ function showThemes() {
+ themePopup.style.display = 'block';
+ themeToggleButton.setAttribute('aria-expanded', true);
+ themePopup.querySelector("button#" + get_theme()).focus();
+ }
+
+ function updateThemeSelected() {
+ themePopup.querySelectorAll('.theme-selected').forEach(function (el) {
+ el.classList.remove('theme-selected');
+ });
+ themePopup.querySelector("button#" + get_theme()).classList.add('theme-selected');
+ }
+
+ function hideThemes() {
+ themePopup.style.display = 'none';
+ themeToggleButton.setAttribute('aria-expanded', false);
+ themeToggleButton.focus();
+ }
+
+ function get_theme() {
+ var theme;
+ try { theme = localStorage.getItem('mdbook-theme'); } catch (e) { }
+ if (theme === null || theme === undefined) {
+ return default_theme;
+ } else {
+ return theme;
+ }
+ }
+
+ function set_theme(theme, store = true) {
+ let ace_theme;
+
+ if (theme == 'coal' || theme == 'navy') {
+ stylesheets.ayuHighlight.disabled = true;
+ stylesheets.tomorrowNight.disabled = false;
+ stylesheets.highlight.disabled = true;
+
+ ace_theme = "ace/theme/tomorrow_night";
+ } else if (theme == 'ayu') {
+ stylesheets.ayuHighlight.disabled = false;
+ stylesheets.tomorrowNight.disabled = true;
+ stylesheets.highlight.disabled = true;
+ ace_theme = "ace/theme/tomorrow_night";
+ } else {
+ stylesheets.ayuHighlight.disabled = true;
+ stylesheets.tomorrowNight.disabled = true;
+ stylesheets.highlight.disabled = false;
+ ace_theme = "ace/theme/dawn";
+ }
+
+ setTimeout(function () {
+ themeColorMetaTag.content = getComputedStyle(document.body).backgroundColor;
+ }, 1);
+
+ if (window.ace && window.editors) {
+ window.editors.forEach(function (editor) {
+ editor.setTheme(ace_theme);
+ });
+ }
+
+ var previousTheme = get_theme();
+
+ if (store) {
+ try { localStorage.setItem('mdbook-theme', theme); } catch (e) { }
+ }
+
+ html.classList.remove(previousTheme);
+ html.classList.add(theme);
+ updateThemeSelected();
+ }
+
+ // Set theme
+ var theme = get_theme();
+
+ set_theme(theme, false);
+
+ themeToggleButton.addEventListener('click', function () {
+ if (themePopup.style.display === 'block') {
+ hideThemes();
+ } else {
+ showThemes();
+ }
+ });
+
+ themePopup.addEventListener('click', function (e) {
+ var theme;
+ if (e.target.className === "theme") {
+ theme = e.target.id;
+ } else if (e.target.parentElement.className === "theme") {
+ theme = e.target.parentElement.id;
+ } else {
+ return;
+ }
+ set_theme(theme);
+ });
+
+ themePopup.addEventListener('focusout', function(e) {
+ // e.relatedTarget is null in Safari and Firefox on macOS (see workaround below)
+ if (!!e.relatedTarget && !themeToggleButton.contains(e.relatedTarget) && !themePopup.contains(e.relatedTarget)) {
+ hideThemes();
+ }
+ });
+
+ // Should not be needed, but it works around an issue on macOS & iOS: https://github.com/rust-lang/mdBook/issues/628
+ document.addEventListener('click', function(e) {
+ if (themePopup.style.display === 'block' && !themeToggleButton.contains(e.target) && !themePopup.contains(e.target)) {
+ hideThemes();
+ }
+ });
+
+ document.addEventListener('keydown', function (e) {
+ if (e.altKey || e.ctrlKey || e.metaKey || e.shiftKey) { return; }
+ if (!themePopup.contains(e.target)) { return; }
+
+ switch (e.key) {
+ case 'Escape':
+ e.preventDefault();
+ hideThemes();
+ break;
+ case 'ArrowUp':
+ e.preventDefault();
+ var li = document.activeElement.parentElement;
+ if (li && li.previousElementSibling) {
+ li.previousElementSibling.querySelector('button').focus();
+ }
+ break;
+ case 'ArrowDown':
+ e.preventDefault();
+ var li = document.activeElement.parentElement;
+ if (li && li.nextElementSibling) {
+ li.nextElementSibling.querySelector('button').focus();
+ }
+ break;
+ case 'Home':
+ e.preventDefault();
+ themePopup.querySelector('li:first-child button').focus();
+ break;
+ case 'End':
+ e.preventDefault();
+ themePopup.querySelector('li:last-child button').focus();
+ break;
+ }
+ });
+})();
+
+(function sidebar() {
+ var html = document.querySelector("html");
+ var sidebar = document.getElementById("sidebar");
+ var sidebarLinks = document.querySelectorAll('#sidebar a');
+ var sidebarToggleButton = document.getElementById("sidebar-toggle");
+ var sidebarResizeHandle = document.getElementById("sidebar-resize-handle");
+ var firstContact = null;
+
+ function showSidebar() {
+ html.classList.remove('sidebar-hidden')
+ html.classList.add('sidebar-visible');
+ Array.from(sidebarLinks).forEach(function (link) {
+ link.setAttribute('tabIndex', 0);
+ });
+ sidebarToggleButton.setAttribute('aria-expanded', true);
+ sidebar.setAttribute('aria-hidden', false);
+ try { localStorage.setItem('mdbook-sidebar', 'visible'); } catch (e) { }
+ }
+
+
+ var sidebarAnchorToggles = document.querySelectorAll('#sidebar a.toggle');
+
+ function toggleSection(ev) {
+ ev.currentTarget.parentElement.classList.toggle('expanded');
+ }
+
+ Array.from(sidebarAnchorToggles).forEach(function (el) {
+ el.addEventListener('click', toggleSection);
+ });
+
+ function hideSidebar() {
+ html.classList.remove('sidebar-visible')
+ html.classList.add('sidebar-hidden');
+ Array.from(sidebarLinks).forEach(function (link) {
+ link.setAttribute('tabIndex', -1);
+ });
+ sidebarToggleButton.setAttribute('aria-expanded', false);
+ sidebar.setAttribute('aria-hidden', true);
+ try { localStorage.setItem('mdbook-sidebar', 'hidden'); } catch (e) { }
+ }
+
+ // Toggle sidebar
+ sidebarToggleButton.addEventListener('click', function sidebarToggle() {
+ if (html.classList.contains("sidebar-hidden")) {
+ var current_width = parseInt(
+ document.documentElement.style.getPropertyValue('--sidebar-width'), 10);
+ if (current_width < 150) {
+ document.documentElement.style.setProperty('--sidebar-width', '150px');
+ }
+ showSidebar();
+ } else if (html.classList.contains("sidebar-visible")) {
+ hideSidebar();
+ } else {
+ if (getComputedStyle(sidebar)['transform'] === 'none') {
+ hideSidebar();
+ } else {
+ showSidebar();
+ }
+ }
+ });
+
+ sidebarResizeHandle.addEventListener('mousedown', initResize, false);
+
+ function initResize(e) {
+ window.addEventListener('mousemove', resize, false);
+ window.addEventListener('mouseup', stopResize, false);
+ html.classList.add('sidebar-resizing');
+ }
+ function resize(e) {
+ var pos = (e.clientX - sidebar.offsetLeft);
+ if (pos < 20) {
+ hideSidebar();
+ } else {
+ if (html.classList.contains("sidebar-hidden")) {
+ showSidebar();
+ }
+ pos = Math.min(pos, window.innerWidth - 100);
+ document.documentElement.style.setProperty('--sidebar-width', pos + 'px');
+ }
+ }
+ //on mouseup remove windows functions mousemove & mouseup
+ function stopResize(e) {
+ html.classList.remove('sidebar-resizing');
+ window.removeEventListener('mousemove', resize, false);
+ window.removeEventListener('mouseup', stopResize, false);
+ }
+
+ document.addEventListener('touchstart', function (e) {
+ firstContact = {
+ x: e.touches[0].clientX,
+ time: Date.now()
+ };
+ }, { passive: true });
+
+ document.addEventListener('touchmove', function (e) {
+ if (!firstContact)
+ return;
+
+ var curX = e.touches[0].clientX;
+ var xDiff = curX - firstContact.x,
+ tDiff = Date.now() - firstContact.time;
+
+ if (tDiff < 250 && Math.abs(xDiff) >= 150) {
+ if (xDiff >= 0 && firstContact.x < Math.min(document.body.clientWidth * 0.25, 300))
+ showSidebar();
+ else if (xDiff < 0 && curX < 300)
+ hideSidebar();
+
+ firstContact = null;
+ }
+ }, { passive: true });
+
+ // Scroll sidebar to current active section
+ var activeSection = document.getElementById("sidebar").querySelector(".active");
+ if (activeSection) {
+ // https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollIntoView
+ activeSection.scrollIntoView({ block: 'center' });
+ }
+})();
+
+(function chapterNavigation() {
+ document.addEventListener('keydown', function (e) {
+ if (e.altKey || e.ctrlKey || e.metaKey || e.shiftKey) { return; }
+ if (window.search && window.search.hasFocus()) { return; }
+
+ switch (e.key) {
+ case 'ArrowRight':
+ e.preventDefault();
+ var nextButton = document.querySelector('.nav-chapters.next');
+ if (nextButton) {
+ window.location.href = nextButton.href;
+ }
+ break;
+ case 'ArrowLeft':
+ e.preventDefault();
+ var previousButton = document.querySelector('.nav-chapters.previous');
+ if (previousButton) {
+ window.location.href = previousButton.href;
+ }
+ break;
+ }
+ });
+})();
+
+(function clipboard() {
+ var clipButtons = document.querySelectorAll('.clip-button');
+
+ function hideTooltip(elem) {
+ elem.firstChild.innerText = "";
+ elem.className = 'fa fa-copy clip-button';
+ }
+
+ function showTooltip(elem, msg) {
+ elem.firstChild.innerText = msg;
+ elem.className = 'fa fa-copy tooltipped';
+ }
+
+ var clipboardSnippets = new ClipboardJS('.clip-button', {
+ text: function (trigger) {
+ hideTooltip(trigger);
+ let playground = trigger.closest("pre");
+ return playground_text(playground, false);
+ }
+ });
+
+ Array.from(clipButtons).forEach(function (clipButton) {
+ clipButton.addEventListener('mouseout', function (e) {
+ hideTooltip(e.currentTarget);
+ });
+ });
+
+ clipboardSnippets.on('success', function (e) {
+ e.clearSelection();
+ showTooltip(e.trigger, "Copied!");
+ });
+
+ clipboardSnippets.on('error', function (e) {
+ showTooltip(e.trigger, "Clipboard error!");
+ });
+})();
+
+(function scrollToTop () {
+ var menuTitle = document.querySelector('.menu-title');
+
+ menuTitle.addEventListener('click', function () {
+ document.scrollingElement.scrollTo({ top: 0, behavior: 'smooth' });
+ });
+})();
+
+(function controllMenu() {
+ var menu = document.getElementById('menu-bar');
+
+ (function controllPosition() {
+ var scrollTop = document.scrollingElement.scrollTop;
+ var prevScrollTop = scrollTop;
+ var minMenuY = -menu.clientHeight - 50;
+ // When the script loads, the page can be at any scroll (e.g. if you reforesh it).
+ menu.style.top = scrollTop + 'px';
+ // Same as parseInt(menu.style.top.slice(0, -2), but faster
+ var topCache = menu.style.top.slice(0, -2);
+ menu.classList.remove('sticky');
+ var stickyCache = false; // Same as menu.classList.contains('sticky'), but faster
+ document.addEventListener('scroll', function () {
+ scrollTop = Math.max(document.scrollingElement.scrollTop, 0);
+ // `null` means that it doesn't need to be updated
+ var nextSticky = null;
+ var nextTop = null;
+ var scrollDown = scrollTop > prevScrollTop;
+ var menuPosAbsoluteY = topCache - scrollTop;
+ if (scrollDown) {
+ nextSticky = false;
+ if (menuPosAbsoluteY > 0) {
+ nextTop = prevScrollTop;
+ }
+ } else {
+ if (menuPosAbsoluteY > 0) {
+ nextSticky = true;
+ } else if (menuPosAbsoluteY < minMenuY) {
+ nextTop = prevScrollTop + minMenuY;
+ }
+ }
+ if (nextSticky === true && stickyCache === false) {
+ menu.classList.add('sticky');
+ stickyCache = true;
+ } else if (nextSticky === false && stickyCache === true) {
+ menu.classList.remove('sticky');
+ stickyCache = false;
+ }
+ if (nextTop !== null) {
+ menu.style.top = nextTop + 'px';
+ topCache = nextTop;
+ }
+ prevScrollTop = scrollTop;
+ }, { passive: true });
+ })();
+ (function controllBorder() {
+ menu.classList.remove('bordered');
+ document.addEventListener('scroll', function () {
+ if (menu.offsetTop === 0) {
+ menu.classList.remove('bordered');
+ } else {
+ menu.classList.add('bordered');
+ }
+ }, { passive: true });
+ })();
+})();
diff --git a/docs/book/book/clipboard.min.js b/docs/book/book/clipboard.min.js
new file mode 100644
index 000000000000..02c549e35c86
--- /dev/null
+++ b/docs/book/book/clipboard.min.js
@@ -0,0 +1,7 @@
+/*!
+ * clipboard.js v2.0.4
+ * https://zenorocha.github.io/clipboard.js
+ *
+ * Licensed MIT © Zeno Rocha
+ */
+!function(t,e){"object"==typeof exports&&"object"==typeof module?module.exports=e():"function"==typeof define&&define.amd?define([],e):"object"==typeof exports?exports.ClipboardJS=e():t.ClipboardJS=e()}(this,function(){return function(n){var o={};function r(t){if(o[t])return o[t].exports;var e=o[t]={i:t,l:!1,exports:{}};return n[t].call(e.exports,e,e.exports,r),e.l=!0,e.exports}return r.m=n,r.c=o,r.d=function(t,e,n){r.o(t,e)||Object.defineProperty(t,e,{enumerable:!0,get:n})},r.r=function(t){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(t,"__esModule",{value:!0})},r.t=function(e,t){if(1&t&&(e=r(e)),8&t)return e;if(4&t&&"object"==typeof e&&e&&e.__esModule)return e;var n=Object.create(null);if(r.r(n),Object.defineProperty(n,"default",{enumerable:!0,value:e}),2&t&&"string"!=typeof e)for(var o in e)r.d(n,o,function(t){return e[t]}.bind(null,o));return n},r.n=function(t){var e=t&&t.__esModule?function(){return t.default}:function(){return t};return r.d(e,"a",e),e},r.o=function(t,e){return Object.prototype.hasOwnProperty.call(t,e)},r.p="",r(r.s=0)}([function(t,e,n){"use strict";var r="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},i=function(){function o(t,e){for(var n=0;n
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Assists
+Assists, or code actions, are small local refactorings, available in a
+particular context. They are usually triggered by a shortcut or by
+clicking a light bulb icon in the editor. Cursor position or selection
+is signified by ┃ character.
add_braces
+Source: add_braces.rs
+Adds braces to lambda and match arm expressions.
+Before
+fn foo(n: i32) -> i32 {
+ match n {
+ 1 =>┃ n + 1,
+ _ => 0
+ }
+}After
+fn foo(n: i32) -> i32 {
+ match n {
+ 1 => {
+ n + 1
+ },
+ _ => 0
+ }
+}add_explicit_type
+Source: add_explicit_type.rs
+Specify type for a let binding.
+Before
+fn main() {
+ let x┃ = 92;
+}After
+fn main() {
+ let x: i32 = 92;
+}add_hash
+Source: raw_string.rs
+Adds a hash to a raw string literal.
+Before
+fn main() {
+ r#"Hello,┃ World!"#;
+}After
+fn main() {
+ r##"Hello, World!"##;
+}add_impl_default_members
+Source: add_missing_impl_members.rs
+Adds scaffold for overriding default impl members.
+Before
+trait Trait {
+ type X;
+ fn foo(&self);
+ fn bar(&self) {}
+}
+
+impl Trait for () {
+ type X = ();
+ fn foo(&self) {}┃
+}After
+trait Trait {
+ type X;
+ fn foo(&self);
+ fn bar(&self) {}
+}
+
+impl Trait for () {
+ type X = ();
+ fn foo(&self) {}
+
+ ┃fn bar(&self) {}
+}add_impl_missing_members
+Source: add_missing_impl_members.rs
+Adds scaffold for required impl members.
+Before
+trait Trait<T> {
+ type X;
+ fn foo(&self) -> T;
+ fn bar(&self) {}
+}
+
+impl Trait<u32> for () {┃
+
+}After
+trait Trait<T> {
+ type X;
+ fn foo(&self) -> T;
+ fn bar(&self) {}
+}
+
+impl Trait<u32> for () {
+ ┃type X;
+
+ fn foo(&self) -> u32 {
+ todo!()
+ }
+}add_label_to_loop
+Source: add_label_to_loop.rs
+Adds a label to a loop.
+Before
+fn main() {
+ loop┃ {
+ break;
+ continue;
+ }
+}After
+fn main() {
+ 'l: loop {
+ break 'l;
+ continue 'l;
+ }
+}add_lifetime_to_type
+Source: add_lifetime_to_type.rs
+Adds a new lifetime to a struct, enum or union.
+Before
+struct Point {
+ x: &┃u32,
+ y: u32,
+}After
+struct Point<'a> {
+ x: &'a u32,
+ y: u32,
+}add_missing_match_arms
+Source: add_missing_match_arms.rs
+Adds missing clauses to a match expression.
Before
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+ match action {
+ ┃
+ }
+}After
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+ match action {
+ ┃Action::Move { distance } => todo!(),
+ Action::Stop => todo!(),
+ }
+}add_return_type
+Source: add_return_type.rs
+Adds the return type to a function or closure inferred from its tail expression if it doesn't have a return +type specified. This assists is useable in a functions or closures tail expression or return type position.
+Before
+fn foo() { 4┃2i32 }After
+fn foo() -> i32 { 42i32 }add_turbo_fish
+Source: add_turbo_fish.rs
+Adds ::<_> to a call of a generic method or function.
Before
+fn make<T>() -> T { todo!() }
+fn main() {
+ let x = make┃();
+}After
+fn make<T>() -> T { todo!() }
+fn main() {
+ let x = make::<${0:_}>();
+}apply_demorgan
+Source: apply_demorgan.rs
+Apply https://en.wikipedia.org/wiki/De_Morgan%27s_laws[De Morgan's law].
+This transforms expressions of the form !l || !r into !(l && r).
+This also works with &&. This assist can only be applied with the cursor
+on either || or &&.
Before
+fn main() {
+ if x != 4 ||┃ y < 3.14 {}
+}After
+fn main() {
+ if !(x == 4 && y >= 3.14) {}
+}apply_demorgan_iterator
+Source: apply_demorgan.rs
+Apply https://en.wikipedia.org/wiki/De_Morgan%27s_laws[De Morgan's law] to
+Iterator::all and Iterator::any.
This transforms expressions of the form !iter.any(|x| predicate(x)) into
+iter.all(|x| !predicate(x)) and vice versa. This also works the other way for
+Iterator::all into Iterator::any.
Before
+fn main() {
+ let arr = [1, 2, 3];
+ if !arr.into_iter().┃any(|num| num == 4) {
+ println!("foo");
+ }
+}After
+fn main() {
+ let arr = [1, 2, 3];
+ if arr.into_iter().all(|num| num != 4) {
+ println!("foo");
+ }
+}auto_import
+Source: auto_import.rs
+If the name is unresolved, provides all possible imports for it.
+Before
+fn main() {
+ let map = HashMap┃::new();
+}After
+use std::collections::HashMap;
+
+fn main() {
+ let map = HashMap::new();
+}bind_unused_param
+Source: bind_unused_param.rs
+Binds unused function parameter to an underscore.
+Before
+fn some_function(x: i32┃) {}After
+fn some_function(x: i32) {
+ let _ = x;
+}bool_to_enum
+Source: bool_to_enum.rs
+This converts boolean local variables, fields, constants, and statics into a new
+enum with two variants Bool::True and Bool::False, as well as replacing
+all assignments with the variants and replacing all usages with == Bool::True or
+== Bool::False.
Before
+fn main() {
+ let ┃bool = true;
+
+ if bool {
+ println!("foo");
+ }
+}After
+#[derive(PartialEq, Eq)]
+enum Bool { True, False }
+
+fn main() {
+ let bool = Bool::True;
+
+ if bool == Bool::True {
+ println!("foo");
+ }
+}change_visibility
+Source: change_visibility.rs
+Adds or changes existing visibility specifier.
+Before
+┃fn frobnicate() {}After
+pub(crate) fn frobnicate() {}convert_bool_then_to_if
+Source: convert_bool_then.rs
+Converts a bool::then method call to an equivalent if expression.
Before
+fn main() {
+ (0 == 0).then┃(|| val)
+}After
+fn main() {
+ if 0 == 0 {
+ Some(val)
+ } else {
+ None
+ }
+}convert_for_loop_with_for_each
+Source: convert_iter_for_each_to_for.rs
+Converts a for loop into a for_each loop on the Iterator.
+Before
+fn main() {
+ let x = vec![1, 2, 3];
+ for┃ v in x {
+ let y = v * 2;
+ }
+}After
+fn main() {
+ let x = vec![1, 2, 3];
+ x.into_iter().for_each(|v| {
+ let y = v * 2;
+ });
+}convert_if_to_bool_then
+Source: convert_bool_then.rs
+Converts an if expression into a corresponding bool::then call.
Before
+fn main() {
+ if┃ cond {
+ Some(val)
+ } else {
+ None
+ }
+}After
+fn main() {
+ cond.then(|| val)
+}convert_integer_literal
+Source: convert_integer_literal.rs
+Converts the base of integer literals to other bases.
+Before
+const _: i32 = 10┃;After
+const _: i32 = 0b1010;convert_into_to_from
+Source: convert_into_to_from.rs
+Converts an Into impl to an equivalent From impl.
+Before
+impl ┃Into<Thing> for usize {
+ fn into(self) -> Thing {
+ Thing {
+ b: self.to_string(),
+ a: self
+ }
+ }
+}After
+impl From<usize> for Thing {
+ fn from(val: usize) -> Self {
+ Thing {
+ b: val.to_string(),
+ a: val
+ }
+ }
+}convert_iter_for_each_to_for
+Source: convert_iter_for_each_to_for.rs
+Converts an Iterator::for_each function into a for loop.
+Before
+fn main() {
+ let iter = iter::repeat((9, 2));
+ iter.for_each┃(|(x, y)| {
+ println!("x: {}, y: {}", x, y);
+ });
+}After
+fn main() {
+ let iter = iter::repeat((9, 2));
+ for (x, y) in iter {
+ println!("x: {}, y: {}", x, y);
+ }
+}convert_let_else_to_match
+Source: convert_let_else_to_match.rs
+Converts let-else statement to let statement and match expression.
+Before
+fn main() {
+ let Ok(mut x) = f() else┃ { return };
+}After
+fn main() {
+ let mut x = match f() {
+ Ok(x) => x,
+ _ => return,
+ };
+}convert_match_to_let_else
+Source: convert_match_to_let_else.rs
+Converts let statement with match initializer to let-else statement.
+Before
+fn foo(opt: Option<()>) {
+ let val┃ = match opt {
+ Some(it) => it,
+ None => return,
+ };
+}After
+fn foo(opt: Option<()>) {
+ let Some(val) = opt else { return };
+}convert_named_struct_to_tuple_struct
+Source: convert_named_struct_to_tuple_struct.rs
+Converts struct with named fields to tuple struct, and analogously for enum variants with named +fields.
+Before
+struct Point┃ { x: f32, y: f32 }
+
+impl Point {
+ pub fn new(x: f32, y: f32) -> Self {
+ Point { x, y }
+ }
+
+ pub fn x(&self) -> f32 {
+ self.x
+ }
+
+ pub fn y(&self) -> f32 {
+ self.y
+ }
+}After
+struct Point(f32, f32);
+
+impl Point {
+ pub fn new(x: f32, y: f32) -> Self {
+ Point(x, y)
+ }
+
+ pub fn x(&self) -> f32 {
+ self.0
+ }
+
+ pub fn y(&self) -> f32 {
+ self.1
+ }
+}convert_nested_function_to_closure
+Source: convert_nested_function_to_closure.rs
+Converts a function that is defined within the body of another function into a closure.
+Before
+fn main() {
+ fn fo┃o(label: &str, number: u64) {
+ println!("{}: {}", label, number);
+ }
+
+ foo("Bar", 100);
+}After
+fn main() {
+ let foo = |label: &str, number: u64| {
+ println!("{}: {}", label, number);
+ };
+
+ foo("Bar", 100);
+}convert_to_guarded_return
+Source: convert_to_guarded_return.rs
+Replace a large conditional with a guarded return.
+Before
+fn main() {
+ ┃if cond {
+ foo();
+ bar();
+ }
+}After
+fn main() {
+ if !cond {
+ return;
+ }
+ foo();
+ bar();
+}convert_tuple_return_type_to_struct
+Source: convert_tuple_return_type_to_struct.rs
+This converts the return type of a function from a tuple type +into a tuple struct and updates the body accordingly.
+Before
+fn bar() {
+ let (a, b, c) = foo();
+}
+
+fn foo() -> (┃u32, u32, u32) {
+ (1, 2, 3)
+}After
+fn bar() {
+ let FooResult(a, b, c) = foo();
+}
+
+struct FooResult(u32, u32, u32);
+
+fn foo() -> FooResult {
+ FooResult(1, 2, 3)
+}convert_tuple_struct_to_named_struct
+Source: convert_tuple_struct_to_named_struct.rs
+Converts tuple struct to struct with named fields, and analogously for tuple enum variants.
+Before
+struct Point┃(f32, f32);
+
+impl Point {
+ pub fn new(x: f32, y: f32) -> Self {
+ Point(x, y)
+ }
+
+ pub fn x(&self) -> f32 {
+ self.0
+ }
+
+ pub fn y(&self) -> f32 {
+ self.1
+ }
+}After
+struct Point { field1: f32, field2: f32 }
+
+impl Point {
+ pub fn new(x: f32, y: f32) -> Self {
+ Point { field1: x, field2: y }
+ }
+
+ pub fn x(&self) -> f32 {
+ self.field1
+ }
+
+ pub fn y(&self) -> f32 {
+ self.field2
+ }
+}convert_two_arm_bool_match_to_matches_macro
+Source: convert_two_arm_bool_match_to_matches_macro.rs
+Convert 2-arm match that evaluates to a boolean into the equivalent matches! invocation.
+Before
+fn main() {
+ match scrutinee┃ {
+ Some(val) if val.cond() => true,
+ _ => false,
+ }
+}After
+fn main() {
+ matches!(scrutinee, Some(val) if val.cond())
+}convert_while_to_loop
+Source: convert_while_to_loop.rs
+Replace a while with a loop.
+Before
+fn main() {
+ ┃while cond {
+ foo();
+ }
+}After
+fn main() {
+ loop {
+ if !cond {
+ break;
+ }
+ foo();
+ }
+}destructure_tuple_binding
+Source: destructure_tuple_binding.rs
+Destructures a tuple binding in place.
+Before
+fn main() {
+ let ┃t = (1,2);
+ let v = t.0;
+}After
+fn main() {
+ let (┃_0, _1) = (1,2);
+ let v = _0;
+}desugar_doc_comment
+Source: desugar_doc_comment.rs
+Desugars doc-comments to the attribute form.
+Before
+/// Multi-line┃
+/// commentAfter
+#[doc = r"Multi-line
+comment"]expand_glob_import
+Source: expand_glob_import.rs
+Expands glob imports.
+Before
+mod foo {
+ pub struct Bar;
+ pub struct Baz;
+}
+
+use foo::*┃;
+
+fn qux(bar: Bar, baz: Baz) {}After
+mod foo {
+ pub struct Bar;
+ pub struct Baz;
+}
+
+use foo::{Bar, Baz};
+
+fn qux(bar: Bar, baz: Baz) {}extract_expressions_from_format_string
+Source: extract_expressions_from_format_string.rs
+Move an expression out of a format string.
+Before
+fn main() {
+ print!("{var} {x + 1}┃");
+}After
+fn main() {
+ print!("{var} {}"┃, x + 1);
+}extract_function
+Source: extract_function.rs
+Extracts selected statements and comments into new function.
+Before
+fn main() {
+ let n = 1;
+ ┃let m = n + 2;
+ // calculate
+ let k = m + n;┃
+ let g = 3;
+}After
+fn main() {
+ let n = 1;
+ fun_name(n);
+ let g = 3;
+}
+
+fn ┃fun_name(n: i32) {
+ let m = n + 2;
+ // calculate
+ let k = m + n;
+}extract_module
+Source: extract_module.rs
+Extracts a selected region as separate module. All the references, visibility and imports are +resolved.
+Before
+┃fn foo(name: i32) -> i32 {
+ name + 1
+}┃
+
+fn bar(name: i32) -> i32 {
+ name + 2
+}After
+mod modname {
+ pub(crate) fn foo(name: i32) -> i32 {
+ name + 1
+ }
+}
+
+fn bar(name: i32) -> i32 {
+ name + 2
+}extract_struct_from_enum_variant
+Source: extract_struct_from_enum_variant.rs
+Extracts a struct from enum variant.
+Before
+enum A { ┃One(u32, u32) }After
+struct One(u32, u32);
+
+enum A { One(One) }extract_type_alias
+Source: extract_type_alias.rs
+Extracts the selected type as a type alias.
+Before
+struct S {
+ field: ┃(u8, u8, u8)┃,
+}After
+type ┃Type = (u8, u8, u8);
+
+struct S {
+ field: Type,
+}extract_variable
+Source: extract_variable.rs
+Extracts subexpression into a variable.
+Before
+fn main() {
+ ┃(1 + 2)┃ * 4;
+}After
+fn main() {
+ let ┃var_name = (1 + 2);
+ var_name * 4;
+}fix_visibility
+Source: fix_visibility.rs
+Makes inaccessible item public.
+Before
+mod m {
+ fn frobnicate() {}
+}
+fn main() {
+ m::frobnicate┃();
+}After
+mod m {
+ ┃pub(crate) fn frobnicate() {}
+}
+fn main() {
+ m::frobnicate();
+}flip_binexpr
+Source: flip_binexpr.rs
+Flips operands of a binary expression.
+Before
+fn main() {
+ let _ = 90 +┃ 2;
+}After
+fn main() {
+ let _ = 2 + 90;
+}flip_comma
+Source: flip_comma.rs
+Flips two comma-separated items.
+Before
+fn main() {
+ ((1, 2),┃ (3, 4));
+}After
+fn main() {
+ ((3, 4), (1, 2));
+}flip_trait_bound
+Source: flip_trait_bound.rs
+Flips two trait bounds.
+Before
+fn foo<T: Clone +┃ Copy>() { }After
+fn foo<T: Copy + Clone>() { }generate_constant
+Source: generate_constant.rs
+Generate a named constant.
+Before
+struct S { i: usize }
+impl S { pub fn new(n: usize) {} }
+fn main() {
+ let v = S::new(CAPA┃CITY);
+}After
+struct S { i: usize }
+impl S { pub fn new(n: usize) {} }
+fn main() {
+ const CAPACITY: usize = ┃;
+ let v = S::new(CAPACITY);
+}generate_default_from_enum_variant
+Source: generate_default_from_enum_variant.rs
+Adds a Default impl for an enum using a variant.
+Before
+enum Version {
+ Undefined,
+ Minor┃,
+ Major,
+}After
+enum Version {
+ Undefined,
+ Minor,
+ Major,
+}
+
+impl Default for Version {
+ fn default() -> Self {
+ Self::Minor
+ }
+}generate_default_from_new
+Source: generate_default_from_new.rs
+Generates default implementation from new method.
+Before
+struct Example { _inner: () }
+
+impl Example {
+ pub fn n┃ew() -> Self {
+ Self { _inner: () }
+ }
+}After
+struct Example { _inner: () }
+
+impl Example {
+ pub fn new() -> Self {
+ Self { _inner: () }
+ }
+}
+
+impl Default for Example {
+ fn default() -> Self {
+ Self::new()
+ }
+}generate_delegate_methods
+Source: generate_delegate_methods.rs
+Generate delegate methods.
+Before
+struct Age(u8);
+impl Age {
+ fn age(&self) -> u8 {
+ self.0
+ }
+}
+
+struct Person {
+ ag┃e: Age,
+}After
+struct Age(u8);
+impl Age {
+ fn age(&self) -> u8 {
+ self.0
+ }
+}
+
+struct Person {
+ age: Age,
+}
+
+impl Person {
+ ┃fn age(&self) -> u8 {
+ self.age.age()
+ }
+}generate_delegate_trait
+Source: generate_delegate_trait.rs
+Generate delegate trait implementation for StructFields.
Before
+trait SomeTrait {
+ type T;
+ fn fn_(arg: u32) -> u32;
+ fn method_(&mut self) -> bool;
+}
+struct A;
+impl SomeTrait for A {
+ type T = u32;
+
+ fn fn_(arg: u32) -> u32 {
+ 42
+ }
+
+ fn method_(&mut self) -> bool {
+ false
+ }
+}
+struct B {
+ a┃: A,
+}After
+trait SomeTrait {
+ type T;
+ fn fn_(arg: u32) -> u32;
+ fn method_(&mut self) -> bool;
+}
+struct A;
+impl SomeTrait for A {
+ type T = u32;
+
+ fn fn_(arg: u32) -> u32 {
+ 42
+ }
+
+ fn method_(&mut self) -> bool {
+ false
+ }
+}
+struct B {
+ a: A,
+}
+
+impl SomeTrait for B {
+ type T = <A as SomeTrait>::T;
+
+ fn fn_(arg: u32) -> u32 {
+ <A as SomeTrait>::fn_(arg)
+ }
+
+ fn method_(&mut self) -> bool {
+ <A as SomeTrait>::method_( &mut self.a )
+ }
+}generate_deref
+Source: generate_deref.rs
+Generate Deref impl using the given struct field.
Before
+struct A;
+struct B {
+ ┃a: A
+}After
+struct A;
+struct B {
+ a: A
+}
+
+impl core::ops::Deref for B {
+ type Target = A;
+
+ fn deref(&self) -> &Self::Target {
+ &self.a
+ }
+}generate_derive
+Source: generate_derive.rs
+Adds a new #[derive()] clause to a struct or enum.
Before
+struct Point {
+ x: u32,
+ y: u32,┃
+}After
+#[derive(┃)]
+struct Point {
+ x: u32,
+ y: u32,
+}generate_doc_example
+Source: generate_documentation_template.rs
+Generates a rustdoc example when editing an item's documentation.
+Before
+/// Adds two numbers.┃
+pub fn add(a: i32, b: i32) -> i32 { a + b }After
+/// Adds two numbers.
+///
+/// # Examples
+///
+/// ```
+/// use test::add;
+///
+/// assert_eq!(add(a, b), );
+/// ```
+pub fn add(a: i32, b: i32) -> i32 { a + b }generate_documentation_template
+Source: generate_documentation_template.rs
+Adds a documentation template above a function definition / declaration.
+Before
+pub struct S;
+impl S {
+ pub unsafe fn set_len┃(&mut self, len: usize) -> Result<(), std::io::Error> {
+ /* ... */
+ }
+}After
+pub struct S;
+impl S {
+ /// Sets the length of this [`S`].
+ ///
+ /// # Errors
+ ///
+ /// This function will return an error if .
+ ///
+ /// # Safety
+ ///
+ /// .
+ pub unsafe fn set_len(&mut self, len: usize) -> Result<(), std::io::Error> {
+ /* ... */
+ }
+}generate_enum_as_method
+Source: generate_enum_projection_method.rs
+Generate an as_ method for this enum variant.
Before
+enum Value {
+ Number(i32),
+ Text(String)┃,
+}After
+enum Value {
+ Number(i32),
+ Text(String),
+}
+
+impl Value {
+ fn as_text(&self) -> Option<&String> {
+ if let Self::Text(v) = self {
+ Some(v)
+ } else {
+ None
+ }
+ }
+}generate_enum_is_method
+Source: generate_enum_is_method.rs
+Generate an is_ method for this enum variant.
Before
+enum Version {
+ Undefined,
+ Minor┃,
+ Major,
+}After
+enum Version {
+ Undefined,
+ Minor,
+ Major,
+}
+
+impl Version {
+ /// Returns `true` if the version is [`Minor`].
+ ///
+ /// [`Minor`]: Version::Minor
+ #[must_use]
+ fn is_minor(&self) -> bool {
+ matches!(self, Self::Minor)
+ }
+}generate_enum_try_into_method
+Source: generate_enum_projection_method.rs
+Generate a try_into_ method for this enum variant.
Before
+enum Value {
+ Number(i32),
+ Text(String)┃,
+}After
+enum Value {
+ Number(i32),
+ Text(String),
+}
+
+impl Value {
+ fn try_into_text(self) -> Result<String, Self> {
+ if let Self::Text(v) = self {
+ Ok(v)
+ } else {
+ Err(self)
+ }
+ }
+}generate_enum_variant
+Source: generate_enum_variant.rs
+Adds a variant to an enum.
+Before
+enum Countries {
+ Ghana,
+}
+
+fn main() {
+ let country = Countries::Lesotho┃;
+}After
+enum Countries {
+ Ghana,
+ Lesotho,
+}
+
+fn main() {
+ let country = Countries::Lesotho;
+}generate_from_impl_for_enum
+Source: generate_from_impl_for_enum.rs
+Adds a From impl for this enum variant with one tuple field.
+Before
+enum A { ┃One(u32) }After
+enum A { One(u32) }
+
+impl From<u32> for A {
+ fn from(v: u32) -> Self {
+ Self::One(v)
+ }
+}generate_function
+Source: generate_function.rs
+Adds a stub function with a signature matching the function under the cursor.
+Before
+struct Baz;
+fn baz() -> Baz { Baz }
+fn foo() {
+ bar┃("", baz());
+}
+After
+struct Baz;
+fn baz() -> Baz { Baz }
+fn foo() {
+ bar("", baz());
+}
+
+fn bar(arg: &str, baz: Baz) ${0:-> _} {
+ todo!()
+}
+generate_getter
+Source: generate_getter_or_setter.rs
+Generate a getter method.
+Before
+struct Person {
+ nam┃e: String,
+}After
+struct Person {
+ name: String,
+}
+
+impl Person {
+ fn ┃name(&self) -> &str {
+ self.name.as_ref()
+ }
+}generate_getter_mut
+Source: generate_getter_or_setter.rs
+Generate a mut getter method.
+Before
+struct Person {
+ nam┃e: String,
+}After
+struct Person {
+ name: String,
+}
+
+impl Person {
+ fn ┃name_mut(&mut self) -> &mut String {
+ &mut self.name
+ }
+}generate_impl
+Source: generate_impl.rs
+Adds a new inherent impl for a type.
+Before
+struct Ctx┃<T: Clone> {
+ data: T,
+}After
+struct Ctx<T: Clone> {
+ data: T,
+}
+
+impl<T: Clone> Ctx<T> {
+ ┃
+}generate_is_empty_from_len
+Source: generate_is_empty_from_len.rs
+Generates is_empty implementation from the len method.
+Before
+struct MyStruct { data: Vec<String> }
+
+impl MyStruct {
+ #[must_use]
+ p┃ub fn len(&self) -> usize {
+ self.data.len()
+ }
+}After
+struct MyStruct { data: Vec<String> }
+
+impl MyStruct {
+ #[must_use]
+ pub fn len(&self) -> usize {
+ self.data.len()
+ }
+
+ #[must_use]
+ pub fn is_empty(&self) -> bool {
+ self.len() == 0
+ }
+}generate_new
+Source: generate_new.rs
+Adds a fn new for a type.
Before
+struct Ctx<T: Clone> {
+ data: T,┃
+}After
+struct Ctx<T: Clone> {
+ data: T,
+}
+
+impl<T: Clone> Ctx<T> {
+ fn ┃new(data: T) -> Self { Self { data } }
+}generate_setter
+Source: generate_getter_or_setter.rs
+Generate a setter method.
+Before
+struct Person {
+ nam┃e: String,
+}After
+struct Person {
+ name: String,
+}
+
+impl Person {
+ fn ┃set_name(&mut self, name: String) {
+ self.name = name;
+ }
+}generate_trait_from_impl
+Source: generate_trait_from_impl.rs
+Generate trait for an already defined inherent impl and convert impl to a trait impl.
+Before
+struct Foo<const N: usize>([i32; N]);
+
+macro_rules! const_maker {
+ ($t:ty, $v:tt) => {
+ const CONST: $t = $v;
+ };
+}
+
+impl<const N: usize> Fo┃o<N> {
+ // Used as an associated constant.
+ const CONST_ASSOC: usize = N * 4;
+
+ fn create() -> Option<()> {
+ Some(())
+ }
+
+ const_maker! {i32, 7}
+}After
+struct Foo<const N: usize>([i32; N]);
+
+macro_rules! const_maker {
+ ($t:ty, $v:tt) => {
+ const CONST: $t = $v;
+ };
+}
+
+trait ${0:TraitName}<const N: usize> {
+ // Used as an associated constant.
+ const CONST_ASSOC: usize = N * 4;
+
+ fn create() -> Option<()>;
+
+ const_maker! {i32, 7}
+}
+
+impl<const N: usize> ${0:TraitName}<N> for Foo<N> {
+ // Used as an associated constant.
+ const CONST_ASSOC: usize = N * 4;
+
+ fn create() -> Option<()> {
+ Some(())
+ }
+
+ const_maker! {i32, 7}
+}generate_trait_impl
+Source: generate_impl.rs
+Adds a new trait impl for a type.
+Before
+struct ┃Ctx<T: Clone> {
+ data: T,
+}After
+struct Ctx<T: Clone> {
+ data: T,
+}
+
+impl<T: Clone> ┃ for Ctx<T> {
+
+}inline_call
+Source: inline_call.rs
+Inlines a function or method body creating a let statement per parameter unless the parameter
+can be inlined. The parameter will be inlined either if it the supplied argument is a simple local
+or if the parameter is only accessed inside the function body once.
Before
+fn foo(name: Option<&str>) {
+ let name = name.unwrap┃();
+}After
+fn foo(name: Option<&str>) {
+ let name = match name {
+ Some(val) => val,
+ None => panic!("called `Option::unwrap()` on a `None` value"),
+ };
+}inline_const_as_literal
+Source: inline_const_as_literal.rs
+Evaluate and inline const variable as literal.
+Before
+const STRING: &str = "Hello, World!";
+
+fn something() -> &'static str {
+ STRING┃
+}After
+const STRING: &str = "Hello, World!";
+
+fn something() -> &'static str {
+ "Hello, World!"
+}inline_into_callers
+Source: inline_call.rs
+Inline a function or method body into all of its callers where possible, creating a let statement per parameter
+unless the parameter can be inlined. The parameter will be inlined either if it the supplied argument is a simple local
+or if the parameter is only accessed inside the function body once.
+If all calls can be inlined the function will be removed.
Before
+fn print(_: &str) {}
+fn foo┃(word: &str) {
+ if !word.is_empty() {
+ print(word);
+ }
+}
+fn bar() {
+ foo("안녕하세요");
+ foo("여러분");
+}After
+fn print(_: &str) {}
+
+fn bar() {
+ {
+ let word = "안녕하세요";
+ if !word.is_empty() {
+ print(word);
+ }
+ };
+ {
+ let word = "여러분";
+ if !word.is_empty() {
+ print(word);
+ }
+ };
+}inline_local_variable
+Source: inline_local_variable.rs
+Inlines a local variable.
+Before
+fn main() {
+ let x┃ = 1 + 2;
+ x * 4;
+}After
+fn main() {
+ (1 + 2) * 4;
+}inline_macro
+Source: inline_macro.rs
+Takes a macro and inlines it one step.
+Before
+macro_rules! num {
+ (+$($t:tt)+) => (1 + num!($($t )+));
+ (-$($t:tt)+) => (-1 + num!($($t )+));
+ (+) => (1);
+ (-) => (-1);
+}
+
+fn main() {
+ let number = num┃!(+ + + - + +);
+ println!("{number}");
+}After
+macro_rules! num {
+ (+$($t:tt)+) => (1 + num!($($t )+));
+ (-$($t:tt)+) => (-1 + num!($($t )+));
+ (+) => (1);
+ (-) => (-1);
+}
+
+fn main() {
+ let number = 1+num!(+ + - + +);
+ println!("{number}");
+}inline_type_alias
+Source: inline_type_alias.rs
+Replace a type alias with its concrete type.
+Before
+type A<T = u32> = Vec<T>;
+
+fn main() {
+ let a: ┃A;
+}After
+type A<T = u32> = Vec<T>;
+
+fn main() {
+ let a: Vec<u32>;
+}inline_type_alias_uses
+Source: inline_type_alias.rs
+Inline a type alias into all of its uses where possible.
+Before
+type ┃A = i32;
+fn id(x: A) -> A {
+ x
+};
+fn foo() {
+ let _: A = 3;
+}After
+
+fn id(x: i32) -> i32 {
+ x
+};
+fn foo() {
+ let _: i32 = 3;
+}into_to_qualified_from
+Source: into_to_qualified_from.rs
+Convert an into method call to a fully qualified from call.
Before
+//- minicore: from
+struct B;
+impl From<i32> for B {
+ fn from(a: i32) -> Self {
+ B
+ }
+}
+
+fn main() -> () {
+ let a = 3;
+ let b: B = a.in┃to();
+}After
+struct B;
+impl From<i32> for B {
+ fn from(a: i32) -> Self {
+ B
+ }
+}
+
+fn main() -> () {
+ let a = 3;
+ let b: B = B::from(a);
+}introduce_named_generic
+Source: introduce_named_generic.rs
+Replaces impl Trait function argument with the named generic.
Before
+fn foo(bar: ┃impl Bar) {}After
+fn foo<┃B: Bar>(bar: B) {}introduce_named_lifetime
+Source: introduce_named_lifetime.rs
+Change an anonymous lifetime to a named lifetime.
+Before
+impl Cursor<'_┃> {
+ fn node(self) -> &SyntaxNode {
+ match self {
+ Cursor::Replace(node) | Cursor::Before(node) => node,
+ }
+ }
+}After
+impl<'a> Cursor<'a> {
+ fn node(self) -> &SyntaxNode {
+ match self {
+ Cursor::Replace(node) | Cursor::Before(node) => node,
+ }
+ }
+}invert_if
+Source: invert_if.rs
+This transforms if expressions of the form if !x {A} else {B} into if x {B} else {A}
+This also works with !=. This assist can only be applied with the cursor on if.
Before
+fn main() {
+ if┃ !y { A } else { B }
+}After
+fn main() {
+ if y { B } else { A }
+}line_to_block
+Source: convert_comment_block.rs
+Converts comments between block and single-line form.
+Before
+ // Multi-line┃
+ // commentAfter
+ /*
+ Multi-line
+ comment
+ */make_raw_string
+Source: raw_string.rs
+Adds r# to a plain string literal.
Before
+fn main() {
+ "Hello,┃ World!";
+}After
+fn main() {
+ r#"Hello, World!"#;
+}make_usual_string
+Source: raw_string.rs
+Turns a raw string into a plain string.
+Before
+fn main() {
+ r#"Hello,┃ "World!""#;
+}After
+fn main() {
+ "Hello, \"World!\"";
+}merge_imports
+Source: merge_imports.rs
+Merges two imports with a common prefix.
+Before
+use std::┃fmt::Formatter;
+use std::io;After
+use std::{fmt::Formatter, io};merge_match_arms
+Source: merge_match_arms.rs
+Merges the current match arm with the following if their bodies are identical.
+Before
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+ match action {
+ ┃Action::Move(..) => foo(),
+ Action::Stop => foo(),
+ }
+}After
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+ match action {
+ Action::Move(..) | Action::Stop => foo(),
+ }
+}move_arm_cond_to_match_guard
+Source: move_guard.rs
+Moves if expression from match arm body into a guard.
+Before
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+ match action {
+ Action::Move { distance } => ┃if distance > 10 { foo() },
+ _ => (),
+ }
+}After
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+ match action {
+ Action::Move { distance } if distance > 10 => foo(),
+ _ => (),
+ }
+}move_bounds_to_where_clause
+Source: move_bounds.rs
+Moves inline type bounds to a where clause.
+Before
+fn apply<T, U, ┃F: FnOnce(T) -> U>(f: F, x: T) -> U {
+ f(x)
+}After
+fn apply<T, U, F>(f: F, x: T) -> U where F: FnOnce(T) -> U {
+ f(x)
+}move_const_to_impl
+Source: move_const_to_impl.rs
+Move a local constant item in a method to impl's associated constant. All the references will be
+qualified with Self::.
Before
+struct S;
+impl S {
+ fn foo() -> usize {
+ /// The answer.
+ const C┃: usize = 42;
+
+ C * C
+ }
+}After
+struct S;
+impl S {
+ /// The answer.
+ const C: usize = 42;
+
+ fn foo() -> usize {
+ Self::C * Self::C
+ }
+}move_from_mod_rs
+Source: move_from_mod_rs.rs
+Moves xxx/mod.rs to xxx.rs.
+Before
+//- /main.rs
+mod a;
+//- /a/mod.rs
+┃fn t() {}┃After
+fn t() {}move_guard_to_arm_body
+Source: move_guard.rs
+Moves match guard into match arm body.
+Before
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+ match action {
+ Action::Move { distance } ┃if distance > 10 => foo(),
+ _ => (),
+ }
+}After
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+ match action {
+ Action::Move { distance } => if distance > 10 {
+ foo()
+ },
+ _ => (),
+ }
+}move_module_to_file
+Source: move_module_to_file.rs
+Moves inline module's contents to a separate file.
+Before
+mod ┃foo {
+ fn t() {}
+}After
+mod foo;move_to_mod_rs
+Source: move_to_mod_rs.rs
+Moves xxx.rs to xxx/mod.rs.
+Before
+//- /main.rs
+mod a;
+//- /a.rs
+┃fn t() {}┃After
+fn t() {}promote_local_to_const
+Source: promote_local_to_const.rs
+Promotes a local variable to a const item changing its name to a SCREAMING_SNAKE_CASE variant
+if the local uses no non-const expressions.
Before
+fn main() {
+ let foo┃ = true;
+
+ if foo {
+ println!("It's true");
+ } else {
+ println!("It's false");
+ }
+}After
+fn main() {
+ const ┃FOO: bool = true;
+
+ if FOO {
+ println!("It's true");
+ } else {
+ println!("It's false");
+ }
+}pull_assignment_up
+Source: pull_assignment_up.rs
+Extracts variable assignment to outside an if or match statement.
+Before
+fn main() {
+ let mut foo = 6;
+
+ if true {
+ ┃foo = 5;
+ } else {
+ foo = 4;
+ }
+}After
+fn main() {
+ let mut foo = 6;
+
+ foo = if true {
+ 5
+ } else {
+ 4
+ };
+}qualify_method_call
+Source: qualify_method_call.rs
+Replaces the method call with a qualified function call.
+Before
+struct Foo;
+impl Foo {
+ fn foo(&self) {}
+}
+fn main() {
+ let foo = Foo;
+ foo.fo┃o();
+}After
+struct Foo;
+impl Foo {
+ fn foo(&self) {}
+}
+fn main() {
+ let foo = Foo;
+ Foo::foo(&foo);
+}qualify_path
+Source: qualify_path.rs
+If the name is unresolved, provides all possible qualified paths for it.
+Before
+fn main() {
+ let map = HashMap┃::new();
+}After
+fn main() {
+ let map = std::collections::HashMap::new();
+}reformat_number_literal
+Source: number_representation.rs
+Adds or removes separators from integer literal.
+Before
+const _: i32 = 1012345┃;After
+const _: i32 = 1_012_345;remove_dbg
+Source: remove_dbg.rs
+Removes dbg!() macro call.
Before
+fn main() {
+ let x = ┃dbg!(42 * dbg!(4 + 2));┃
+}After
+fn main() {
+ let x = 42 * (4 + 2);
+}remove_hash
+Source: raw_string.rs
+Removes a hash from a raw string literal.
+Before
+fn main() {
+ r#"Hello,┃ World!"#;
+}After
+fn main() {
+ r"Hello, World!";
+}remove_mut
+Source: remove_mut.rs
+Removes the mut keyword.
Before
+impl Walrus {
+ fn feed(&mut┃ self, amount: u32) {}
+}After
+impl Walrus {
+ fn feed(&self, amount: u32) {}
+}remove_parentheses
+Source: remove_parentheses.rs
+Removes redundant parentheses.
+Before
+fn main() {
+ _ = ┃(2) + 2;
+}After
+fn main() {
+ _ = 2 + 2;
+}remove_unused_imports
+Source: remove_unused_imports.rs
+Removes any use statements in the current selection that are unused.
+Before
+struct X();
+mod foo {
+ use super::X┃;
+}After
+struct X();
+mod foo {
+}remove_unused_param
+Source: remove_unused_param.rs
+Removes unused function parameter.
+Before
+fn frobnicate(x: i32┃) {}
+
+fn main() {
+ frobnicate(92);
+}After
+fn frobnicate() {}
+
+fn main() {
+ frobnicate();
+}reorder_fields
+Source: reorder_fields.rs
+Reorder the fields of record literals and record patterns in the same order as in +the definition.
+Before
+struct Foo {foo: i32, bar: i32};
+const test: Foo = ┃Foo {bar: 0, foo: 1}After
+struct Foo {foo: i32, bar: i32};
+const test: Foo = Foo {foo: 1, bar: 0}reorder_impl_items
+Source: reorder_impl_items.rs
+Reorder the items of an impl Trait. The items will be ordered
+in the same order as in the trait definition.
Before
+trait Foo {
+ type A;
+ const B: u8;
+ fn c();
+}
+
+struct Bar;
+┃impl Foo for Bar┃ {
+ const B: u8 = 17;
+ fn c() {}
+ type A = String;
+}After
+trait Foo {
+ type A;
+ const B: u8;
+ fn c();
+}
+
+struct Bar;
+impl Foo for Bar {
+ type A = String;
+ const B: u8 = 17;
+ fn c() {}
+}replace_arith_with_checked
+Source: replace_arith_op.rs
+Replaces arithmetic on integers with the checked_* equivalent.
Before
+fn main() {
+ let x = 1 ┃+ 2;
+}After
+fn main() {
+ let x = 1.checked_add(2);
+}replace_arith_with_saturating
+Source: replace_arith_op.rs
+Replaces arithmetic on integers with the saturating_* equivalent.
Before
+fn main() {
+ let x = 1 ┃+ 2;
+}After
+fn main() {
+ let x = 1.saturating_add(2);
+}replace_arith_with_wrapping
+Source: replace_arith_op.rs
+Replaces arithmetic on integers with the wrapping_* equivalent.
Before
+fn main() {
+ let x = 1 ┃+ 2;
+}After
+fn main() {
+ let x = 1.wrapping_add(2);
+}replace_char_with_string
+Source: replace_string_with_char.rs
+Replace a char literal with a string literal.
+Before
+fn main() {
+ find('{┃');
+}After
+fn main() {
+ find("{");
+}replace_derive_with_manual_impl
+Source: replace_derive_with_manual_impl.rs
+Converts a derive impl into a manual one.
Before
+#[derive(Deb┃ug, Display)]
+struct S;After
+#[derive(Display)]
+struct S;
+
+impl Debug for S {
+ ┃fn fmt(&self, f: &mut Formatter) -> Result<()> {
+ f.debug_struct("S").finish()
+ }
+}replace_if_let_with_match
+Source: replace_if_let_with_match.rs
+Replaces a if let expression with a match expression.
Before
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+ ┃if let Action::Move { distance } = action {
+ foo(distance)
+ } else {
+ bar()
+ }
+}After
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+ match action {
+ Action::Move { distance } => foo(distance),
+ _ => bar(),
+ }
+}replace_is_some_with_if_let_some
+Source: replace_is_method_with_if_let_method.rs
+Replace if x.is_some() with if let Some(_tmp) = x or if x.is_ok() with if let Ok(_tmp) = x.
Before
+fn main() {
+ let x = Some(1);
+ if x.is_som┃e() {}
+}After
+fn main() {
+ let x = Some(1);
+ if let Some(${0:x}) = x {}
+}replace_let_with_if_let
+Source: replace_let_with_if_let.rs
+Replaces let with an if let.
Before
+
+fn main(action: Action) {
+ ┃let x = compute();
+}
+
+fn compute() -> Option<i32> { None }After
+
+fn main(action: Action) {
+ if let Some(x) = compute() {
+ }
+}
+
+fn compute() -> Option<i32> { None }replace_match_with_if_let
+Source: replace_if_let_with_match.rs
+Replaces a binary match with a wildcard pattern and no guards with an if let expression.
Before
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+ ┃match action {
+ Action::Move { distance } => foo(distance),
+ _ => bar(),
+ }
+}After
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+ if let Action::Move { distance } = action {
+ foo(distance)
+ } else {
+ bar()
+ }
+}replace_named_generic_with_impl
+Source: replace_named_generic_with_impl.rs
+Replaces named generic with an impl Trait in function argument.
Before
+fn new<P┃: AsRef<Path>>(location: P) -> Self {}After
+fn new(location: impl AsRef<Path>) -> Self {}replace_qualified_name_with_use
+Source: replace_qualified_name_with_use.rs
+Adds a use statement for a given fully-qualified name.
+Before
+fn process(map: std::collections::┃HashMap<String, String>) {}After
+use std::collections::HashMap;
+
+fn process(map: HashMap<String, String>) {}replace_string_with_char
+Source: replace_string_with_char.rs
+Replace string literal with char literal.
+Before
+fn main() {
+ find("{┃");
+}After
+fn main() {
+ find('{');
+}replace_try_expr_with_match
+Source: replace_try_expr_with_match.rs
+Replaces a try expression with a match expression.
Before
+fn handle() {
+ let pat = Some(true)┃?;
+}After
+fn handle() {
+ let pat = match Some(true) {
+ Some(it) => it,
+ None => return None,
+ };
+}replace_turbofish_with_explicit_type
+Source: replace_turbofish_with_explicit_type.rs
+Converts ::<_> to an explicit type assignment.
Before
+fn make<T>() -> T { ) }
+fn main() {
+ let a = make┃::<i32>();
+}After
+fn make<T>() -> T { ) }
+fn main() {
+ let a: i32 = make();
+}replace_with_eager_method
+Source: replace_method_eager_lazy.rs
+Replace unwrap_or_else with unwrap_or and ok_or_else with ok_or.
Before
+fn foo() {
+ let a = Some(1);
+ a.unwra┃p_or_else(|| 2);
+}After
+fn foo() {
+ let a = Some(1);
+ a.unwrap_or(2);
+}replace_with_lazy_method
+Source: replace_method_eager_lazy.rs
+Replace unwrap_or with unwrap_or_else and ok_or with ok_or_else.
Before
+fn foo() {
+ let a = Some(1);
+ a.unwra┃p_or(2);
+}After
+fn foo() {
+ let a = Some(1);
+ a.unwrap_or_else(|| 2);
+}sort_items
+Source: sort_items.rs
+Sorts item members alphabetically: fields, enum variants and methods.
+Before
+struct ┃Foo┃ { second: u32, first: String }After
+struct Foo { first: String, second: u32 }+
Before
+trait ┃Bar┃ {
+ fn second(&self) -> u32;
+ fn first(&self) -> String;
+}After
+trait Bar {
+ fn first(&self) -> String;
+ fn second(&self) -> u32;
+}+
Before
+struct Baz;
+impl ┃Baz┃ {
+ fn second(&self) -> u32;
+ fn first(&self) -> String;
+}After
+struct Baz;
+impl Baz {
+ fn first(&self) -> String;
+ fn second(&self) -> u32;
+}+
There is a difference between sorting enum variants:
+Before
+enum ┃Animal┃ {
+ Dog(String, f64),
+ Cat { weight: f64, name: String },
+}After
+enum Animal {
+ Cat { weight: f64, name: String },
+ Dog(String, f64),
+}and sorting a single enum struct variant:
+Before
+enum Animal {
+ Dog(String, f64),
+ Cat ┃{ weight: f64, name: String }┃,
+}After
+enum Animal {
+ Dog(String, f64),
+ Cat { name: String, weight: f64 },
+}split_import
+Source: split_import.rs
+Wraps the tail of import into braces.
+Before
+use std::┃collections::HashMap;After
+use std::{collections::HashMap};toggle_ignore
+Source: toggle_ignore.rs
+Adds #[ignore] attribute to the test.
Before
+┃#[test]
+fn arithmetics {
+ assert_eq!(2 + 2, 5);
+}After
+#[test]
+#[ignore]
+fn arithmetics {
+ assert_eq!(2 + 2, 5);
+}unmerge_match_arm
+Source: unmerge_match_arm.rs
+Splits the current match with a | pattern into two arms with identical bodies.
Before
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+ match action {
+ Action::Move(..) ┃| Action::Stop => foo(),
+ }
+}After
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+ match action {
+ Action::Move(..) => foo(),
+ Action::Stop => foo(),
+ }
+}unmerge_use
+Source: unmerge_use.rs
+Extracts single use item from use list.
+Before
+use std::fmt::{Debug, Display┃};After
+use std::fmt::{Debug};
+use std::fmt::Display;unnecessary_async
+Source: unnecessary_async.rs
+Removes the async mark from functions which have no .await in their body.
+Looks for calls to the functions and removes the .await on the call site.
Before
+pub async f┃n foo() {}
+pub async fn bar() { foo().await }After
+pub fn foo() {}
+pub async fn bar() { foo() }unqualify_method_call
+Source: unqualify_method_call.rs
+Transforms universal function call syntax into a method call.
+Before
+fn main() {
+ std::ops::Add::add┃(1, 2);
+}After
+use std::ops::Add;
+
+fn main() {
+ 1.add(2);
+}unwrap_block
+Source: unwrap_block.rs
+This assist removes if...else, for, while and loop control statements to just keep the body.
+Before
+fn foo() {
+ if true {┃
+ println!("foo");
+ }
+}After
+fn foo() {
+ println!("foo");
+}unwrap_result_return_type
+Source: unwrap_result_return_type.rs
+Unwrap the function's return type.
+Before
+fn foo() -> Result<i32>┃ { Ok(42i32) }After
+fn foo() -> i32 { 42i32 }unwrap_tuple
+Source: unwrap_tuple.rs
+Unwrap the tuple to different variables.
+Before
+fn main() {
+ ┃let (foo, bar) = ("Foo", "Bar");
+}After
+fn main() {
+ let foo = "Foo";
+ let bar = "Bar";
+}wrap_return_type_in_result
+Source: wrap_return_type_in_result.rs
+Wrap the function's return type into Result.
+Before
+fn foo() -> i32┃ { 42i32 }After
+fn foo() -> Result<i32, ${0:_}> { Ok(42i32) }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/book/book/css/chrome.css b/docs/book/book/css/chrome.css
new file mode 100644
index 000000000000..29992f7b6260
--- /dev/null
+++ b/docs/book/book/css/chrome.css
@@ -0,0 +1,545 @@
+/* CSS for UI elements (a.k.a. chrome) */
+
+@import 'variables.css';
+
+html {
+ scrollbar-color: var(--scrollbar) var(--bg);
+}
+#searchresults a,
+.content a:link,
+a:visited,
+a > .hljs {
+ color: var(--links);
+}
+
+/*
+ body-container is necessary because mobile browsers don't seem to like
+ overflow-x on the body tag when there is a tag.
+*/
+#body-container {
+ /*
+ This is used when the sidebar pushes the body content off the side of
+ the screen on small screens. Without it, dragging on mobile Safari
+ will want to reposition the viewport in a weird way.
+ */
+ overflow-x: clip;
+}
+
+/* Menu Bar */
+
+#menu-bar,
+#menu-bar-hover-placeholder {
+ z-index: 101;
+ margin: auto calc(0px - var(--page-padding));
+}
+#menu-bar {
+ position: relative;
+ display: flex;
+ flex-wrap: wrap;
+ background-color: var(--bg);
+ border-bottom-color: var(--bg);
+ border-bottom-width: 1px;
+ border-bottom-style: solid;
+}
+#menu-bar.sticky,
+.js #menu-bar-hover-placeholder:hover + #menu-bar,
+.js #menu-bar:hover,
+.js.sidebar-visible #menu-bar {
+ position: -webkit-sticky;
+ position: sticky;
+ top: 0 !important;
+}
+#menu-bar-hover-placeholder {
+ position: sticky;
+ position: -webkit-sticky;
+ top: 0;
+ height: var(--menu-bar-height);
+}
+#menu-bar.bordered {
+ border-bottom-color: var(--table-border-color);
+}
+#menu-bar i, #menu-bar .icon-button {
+ position: relative;
+ padding: 0 8px;
+ z-index: 10;
+ line-height: var(--menu-bar-height);
+ cursor: pointer;
+ transition: color 0.5s;
+}
+@media only screen and (max-width: 420px) {
+ #menu-bar i, #menu-bar .icon-button {
+ padding: 0 5px;
+ }
+}
+
+.icon-button {
+ border: none;
+ background: none;
+ padding: 0;
+ color: inherit;
+}
+.icon-button i {
+ margin: 0;
+}
+
+.right-buttons {
+ margin: 0 15px;
+}
+.right-buttons a {
+ text-decoration: none;
+}
+
+.left-buttons {
+ display: flex;
+ margin: 0 5px;
+}
+.no-js .left-buttons {
+ display: none;
+}
+
+.menu-title {
+ display: inline-block;
+ font-weight: 200;
+ font-size: 2.4rem;
+ line-height: var(--menu-bar-height);
+ text-align: center;
+ margin: 0;
+ flex: 1;
+ white-space: nowrap;
+ overflow: hidden;
+ text-overflow: ellipsis;
+}
+.js .menu-title {
+ cursor: pointer;
+}
+
+.menu-bar,
+.menu-bar:visited,
+.nav-chapters,
+.nav-chapters:visited,
+.mobile-nav-chapters,
+.mobile-nav-chapters:visited,
+.menu-bar .icon-button,
+.menu-bar a i {
+ color: var(--icons);
+}
+
+.menu-bar i:hover,
+.menu-bar .icon-button:hover,
+.nav-chapters:hover,
+.mobile-nav-chapters i:hover {
+ color: var(--icons-hover);
+}
+
+/* Nav Icons */
+
+.nav-chapters {
+ font-size: 2.5em;
+ text-align: center;
+ text-decoration: none;
+
+ position: fixed;
+ top: 0;
+ bottom: 0;
+ margin: 0;
+ max-width: 150px;
+ min-width: 90px;
+
+ display: flex;
+ justify-content: center;
+ align-content: center;
+ flex-direction: column;
+
+ transition: color 0.5s, background-color 0.5s;
+}
+
+.nav-chapters:hover {
+ text-decoration: none;
+ background-color: var(--theme-hover);
+ transition: background-color 0.15s, color 0.15s;
+}
+
+.nav-wrapper {
+ margin-top: 50px;
+ display: none;
+}
+
+.mobile-nav-chapters {
+ font-size: 2.5em;
+ text-align: center;
+ text-decoration: none;
+ width: 90px;
+ border-radius: 5px;
+ background-color: var(--sidebar-bg);
+}
+
+.previous {
+ float: left;
+}
+
+.next {
+ float: right;
+ right: var(--page-padding);
+}
+
+@media only screen and (max-width: 1080px) {
+ .nav-wide-wrapper { display: none; }
+ .nav-wrapper { display: block; }
+}
+
+@media only screen and (max-width: 1380px) {
+ .sidebar-visible .nav-wide-wrapper { display: none; }
+ .sidebar-visible .nav-wrapper { display: block; }
+}
+
+/* Inline code */
+
+:not(pre) > .hljs {
+ display: inline;
+ padding: 0.1em 0.3em;
+ border-radius: 3px;
+}
+
+:not(pre):not(a) > .hljs {
+ color: var(--inline-code-color);
+ overflow-x: initial;
+}
+
+a:hover > .hljs {
+ text-decoration: underline;
+}
+
+pre {
+ position: relative;
+}
+pre > .buttons {
+ position: absolute;
+ z-index: 100;
+ right: 0px;
+ top: 2px;
+ margin: 0px;
+ padding: 2px 0px;
+
+ color: var(--sidebar-fg);
+ cursor: pointer;
+ visibility: hidden;
+ opacity: 0;
+ transition: visibility 0.1s linear, opacity 0.1s linear;
+}
+pre:hover > .buttons {
+ visibility: visible;
+ opacity: 1
+}
+pre > .buttons :hover {
+ color: var(--sidebar-active);
+ border-color: var(--icons-hover);
+ background-color: var(--theme-hover);
+}
+pre > .buttons i {
+ margin-left: 8px;
+}
+pre > .buttons button {
+ cursor: inherit;
+ margin: 0px 5px;
+ padding: 3px 5px;
+ font-size: 14px;
+
+ border-style: solid;
+ border-width: 1px;
+ border-radius: 4px;
+ border-color: var(--icons);
+ background-color: var(--theme-popup-bg);
+ transition: 100ms;
+ transition-property: color,border-color,background-color;
+ color: var(--icons);
+}
+@media (pointer: coarse) {
+ pre > .buttons button {
+ /* On mobile, make it easier to tap buttons. */
+ padding: 0.3rem 1rem;
+ }
+}
+pre > code {
+ padding: 1rem;
+}
+
+/* FIXME: ACE editors overlap their buttons because ACE does absolute
+ positioning within the code block which breaks padding. The only solution I
+ can think of is to move the padding to the outer pre tag (or insert a div
+ wrapper), but that would require fixing a whole bunch of CSS rules.
+*/
+.hljs.ace_editor {
+ padding: 0rem 0rem;
+}
+
+pre > .result {
+ margin-top: 10px;
+}
+
+/* Search */
+
+#searchresults a {
+ text-decoration: none;
+}
+
+mark {
+ border-radius: 2px;
+ padding: 0 3px 1px 3px;
+ margin: 0 -3px -1px -3px;
+ background-color: var(--search-mark-bg);
+ transition: background-color 300ms linear;
+ cursor: pointer;
+}
+
+mark.fade-out {
+ background-color: rgba(0,0,0,0) !important;
+ cursor: auto;
+}
+
+.searchbar-outer {
+ margin-left: auto;
+ margin-right: auto;
+ max-width: var(--content-max-width);
+}
+
+#searchbar {
+ width: 100%;
+ margin: 5px auto 0px auto;
+ padding: 10px 16px;
+ transition: box-shadow 300ms ease-in-out;
+ border: 1px solid var(--searchbar-border-color);
+ border-radius: 3px;
+ background-color: var(--searchbar-bg);
+ color: var(--searchbar-fg);
+}
+#searchbar:focus,
+#searchbar.active {
+ box-shadow: 0 0 3px var(--searchbar-shadow-color);
+}
+
+.searchresults-header {
+ font-weight: bold;
+ font-size: 1em;
+ padding: 18px 0 0 5px;
+ color: var(--searchresults-header-fg);
+}
+
+.searchresults-outer {
+ margin-left: auto;
+ margin-right: auto;
+ max-width: var(--content-max-width);
+ border-bottom: 1px dashed var(--searchresults-border-color);
+}
+
+ul#searchresults {
+ list-style: none;
+ padding-left: 20px;
+}
+ul#searchresults li {
+ margin: 10px 0px;
+ padding: 2px;
+ border-radius: 2px;
+}
+ul#searchresults li.focus {
+ background-color: var(--searchresults-li-bg);
+}
+ul#searchresults span.teaser {
+ display: block;
+ clear: both;
+ margin: 5px 0 0 20px;
+ font-size: 0.8em;
+}
+ul#searchresults span.teaser em {
+ font-weight: bold;
+ font-style: normal;
+}
+
+/* Sidebar */
+
+.sidebar {
+ position: fixed;
+ left: 0;
+ top: 0;
+ bottom: 0;
+ width: var(--sidebar-width);
+ font-size: 0.875em;
+ box-sizing: border-box;
+ -webkit-overflow-scrolling: touch;
+ overscroll-behavior-y: contain;
+ background-color: var(--sidebar-bg);
+ color: var(--sidebar-fg);
+}
+.sidebar-resizing {
+ -moz-user-select: none;
+ -webkit-user-select: none;
+ -ms-user-select: none;
+ user-select: none;
+}
+.js:not(.sidebar-resizing) .sidebar {
+ transition: transform 0.3s; /* Animation: slide away */
+}
+.sidebar code {
+ line-height: 2em;
+}
+.sidebar .sidebar-scrollbox {
+ overflow-y: auto;
+ position: absolute;
+ top: 0;
+ bottom: 0;
+ left: 0;
+ right: 0;
+ padding: 10px 10px;
+}
+.sidebar .sidebar-resize-handle {
+ position: absolute;
+ cursor: col-resize;
+ width: 0;
+ right: 0;
+ top: 0;
+ bottom: 0;
+}
+.js .sidebar .sidebar-resize-handle {
+ cursor: col-resize;
+ width: 5px;
+}
+.sidebar-hidden .sidebar {
+ transform: translateX(calc(0px - var(--sidebar-width)));
+}
+.sidebar::-webkit-scrollbar {
+ background: var(--sidebar-bg);
+}
+.sidebar::-webkit-scrollbar-thumb {
+ background: var(--scrollbar);
+}
+
+.sidebar-visible .page-wrapper {
+ transform: translateX(var(--sidebar-width));
+}
+@media only screen and (min-width: 620px) {
+ .sidebar-visible .page-wrapper {
+ transform: none;
+ margin-left: var(--sidebar-width);
+ }
+}
+
+.chapter {
+ list-style: none outside none;
+ padding-left: 0;
+ line-height: 2.2em;
+}
+
+.chapter ol {
+ width: 100%;
+}
+
+.chapter li {
+ display: flex;
+ color: var(--sidebar-non-existant);
+}
+.chapter li a {
+ display: block;
+ padding: 0;
+ text-decoration: none;
+ color: var(--sidebar-fg);
+}
+
+.chapter li a:hover {
+ color: var(--sidebar-active);
+}
+
+.chapter li a.active {
+ color: var(--sidebar-active);
+}
+
+.chapter li > a.toggle {
+ cursor: pointer;
+ display: block;
+ margin-left: auto;
+ padding: 0 10px;
+ user-select: none;
+ opacity: 0.68;
+}
+
+.chapter li > a.toggle div {
+ transition: transform 0.5s;
+}
+
+/* collapse the section */
+.chapter li:not(.expanded) + li > ol {
+ display: none;
+}
+
+.chapter li.chapter-item {
+ line-height: 1.5em;
+ margin-top: 0.6em;
+}
+
+.chapter li.expanded > a.toggle div {
+ transform: rotate(90deg);
+}
+
+.spacer {
+ width: 100%;
+ height: 3px;
+ margin: 5px 0px;
+}
+.chapter .spacer {
+ background-color: var(--sidebar-spacer);
+}
+
+@media (-moz-touch-enabled: 1), (pointer: coarse) {
+ .chapter li a { padding: 5px 0; }
+ .spacer { margin: 10px 0; }
+}
+
+.section {
+ list-style: none outside none;
+ padding-left: 20px;
+ line-height: 1.9em;
+}
+
+/* Theme Menu Popup */
+
+.theme-popup {
+ position: absolute;
+ left: 10px;
+ top: var(--menu-bar-height);
+ z-index: 1000;
+ border-radius: 4px;
+ font-size: 0.7em;
+ color: var(--fg);
+ background: var(--theme-popup-bg);
+ border: 1px solid var(--theme-popup-border);
+ margin: 0;
+ padding: 0;
+ list-style: none;
+ display: none;
+ /* Don't let the children's background extend past the rounded corners. */
+ overflow: hidden;
+}
+.theme-popup .default {
+ color: var(--icons);
+}
+.theme-popup .theme {
+ width: 100%;
+ border: 0;
+ margin: 0;
+ padding: 2px 20px;
+ line-height: 25px;
+ white-space: nowrap;
+ text-align: left;
+ cursor: pointer;
+ color: inherit;
+ background: inherit;
+ font-size: inherit;
+}
+.theme-popup .theme:hover {
+ background-color: var(--theme-hover);
+}
+
+.theme-selected::before {
+ display: inline-block;
+ content: "✓";
+ margin-left: -14px;
+ width: 14px;
+}
diff --git a/docs/book/book/css/general.css b/docs/book/book/css/general.css
new file mode 100644
index 000000000000..344b53eb7f9b
--- /dev/null
+++ b/docs/book/book/css/general.css
@@ -0,0 +1,203 @@
+/* Base styles and content styles */
+
+@import 'variables.css';
+
+:root {
+ /* Browser default font-size is 16px, this way 1 rem = 10px */
+ font-size: 62.5%;
+}
+
+html {
+ font-family: "Open Sans", sans-serif;
+ color: var(--fg);
+ background-color: var(--bg);
+ text-size-adjust: none;
+ -webkit-text-size-adjust: none;
+}
+
+body {
+ margin: 0;
+ font-size: 1.6rem;
+ overflow-x: hidden;
+}
+
+code {
+ font-family: var(--mono-font) !important;
+ font-size: var(--code-font-size);
+}
+
+/* make long words/inline code not x overflow */
+main {
+ overflow-wrap: break-word;
+}
+
+/* make wide tables scroll if they overflow */
+.table-wrapper {
+ overflow-x: auto;
+}
+
+/* Don't change font size in headers. */
+h1 code, h2 code, h3 code, h4 code, h5 code, h6 code {
+ font-size: unset;
+}
+
+.left { float: left; }
+.right { float: right; }
+.boring { opacity: 0.6; }
+.hide-boring .boring { display: none; }
+.hidden { display: none !important; }
+
+h2, h3 { margin-top: 2.5em; }
+h4, h5 { margin-top: 2em; }
+
+.header + .header h3,
+.header + .header h4,
+.header + .header h5 {
+ margin-top: 1em;
+}
+
+h1:target::before,
+h2:target::before,
+h3:target::before,
+h4:target::before,
+h5:target::before,
+h6:target::before {
+ display: inline-block;
+ content: "»";
+ margin-left: -30px;
+ width: 30px;
+}
+
+/* This is broken on Safari as of version 14, but is fixed
+ in Safari Technology Preview 117 which I think will be Safari 14.2.
+ https://bugs.webkit.org/show_bug.cgi?id=218076
+*/
+:target {
+ scroll-margin-top: calc(var(--menu-bar-height) + 0.5em);
+}
+
+.page {
+ outline: 0;
+ padding: 0 var(--page-padding);
+ margin-top: calc(0px - var(--menu-bar-height)); /* Compensate for the #menu-bar-hover-placeholder */
+}
+.page-wrapper {
+ box-sizing: border-box;
+}
+.js:not(.sidebar-resizing) .page-wrapper {
+ transition: margin-left 0.3s ease, transform 0.3s ease; /* Animation: slide away */
+}
+
+.content {
+ overflow-y: auto;
+ padding: 0 5px 50px 5px;
+}
+.content main {
+ margin-left: auto;
+ margin-right: auto;
+ max-width: var(--content-max-width);
+}
+.content p { line-height: 1.45em; }
+.content ol { line-height: 1.45em; }
+.content ul { line-height: 1.45em; }
+.content a { text-decoration: none; }
+.content a:hover { text-decoration: underline; }
+.content img, .content video { max-width: 100%; }
+.content .header:link,
+.content .header:visited {
+ color: var(--fg);
+}
+.content .header:link,
+.content .header:visited:hover {
+ text-decoration: none;
+}
+
+table {
+ margin: 0 auto;
+ border-collapse: collapse;
+}
+table td {
+ padding: 3px 20px;
+ border: 1px var(--table-border-color) solid;
+}
+table thead {
+ background: var(--table-header-bg);
+}
+table thead td {
+ font-weight: 700;
+ border: none;
+}
+table thead th {
+ padding: 3px 20px;
+}
+table thead tr {
+ border: 1px var(--table-header-bg) solid;
+}
+/* Alternate background colors for rows */
+table tbody tr:nth-child(2n) {
+ background: var(--table-alternate-bg);
+}
+
+
+blockquote {
+ margin: 20px 0;
+ padding: 0 20px;
+ color: var(--fg);
+ background-color: var(--quote-bg);
+ border-top: .1em solid var(--quote-border);
+ border-bottom: .1em solid var(--quote-border);
+}
+
+kbd {
+ background-color: var(--table-border-color);
+ border-radius: 4px;
+ border: solid 1px var(--theme-popup-border);
+ box-shadow: inset 0 -1px 0 var(--theme-hover);
+ display: inline-block;
+ font-size: var(--code-font-size);
+ font-family: var(--mono-font);
+ line-height: 10px;
+ padding: 4px 5px;
+ vertical-align: middle;
+}
+
+:not(.footnote-definition) + .footnote-definition,
+.footnote-definition + :not(.footnote-definition) {
+ margin-top: 2em;
+}
+.footnote-definition {
+ font-size: 0.9em;
+ margin: 0.5em 0;
+}
+.footnote-definition p {
+ display: inline;
+}
+
+.tooltiptext {
+ position: absolute;
+ visibility: hidden;
+ color: #fff;
+ background-color: #333;
+ transform: translateX(-50%); /* Center by moving tooltip 50% of its width left */
+ left: -8px; /* Half of the width of the icon */
+ top: -35px;
+ font-size: 0.8em;
+ text-align: center;
+ border-radius: 6px;
+ padding: 5px 8px;
+ margin: 5px;
+ z-index: 1000;
+}
+.tooltipped .tooltiptext {
+ visibility: visible;
+}
+
+.chapter li.part-title {
+ color: var(--sidebar-fg);
+ margin: 5px 0px;
+ font-weight: bold;
+}
+
+.result-no-output {
+ font-style: italic;
+}
diff --git a/docs/book/book/css/print.css b/docs/book/book/css/print.css
new file mode 100644
index 000000000000..5e690f755994
--- /dev/null
+++ b/docs/book/book/css/print.css
@@ -0,0 +1,54 @@
+
+#sidebar,
+#menu-bar,
+.nav-chapters,
+.mobile-nav-chapters {
+ display: none;
+}
+
+#page-wrapper.page-wrapper {
+ transform: none;
+ margin-left: 0px;
+ overflow-y: initial;
+}
+
+#content {
+ max-width: none;
+ margin: 0;
+ padding: 0;
+}
+
+.page {
+ overflow-y: initial;
+}
+
+code {
+ background-color: #666666;
+ border-radius: 5px;
+
+ /* Force background to be printed in Chrome */
+ -webkit-print-color-adjust: exact;
+}
+
+pre > .buttons {
+ z-index: 2;
+}
+
+a, a:visited, a:active, a:hover {
+ color: #4183c4;
+ text-decoration: none;
+}
+
+h1, h2, h3, h4, h5, h6 {
+ page-break-inside: avoid;
+ page-break-after: avoid;
+}
+
+pre, code {
+ page-break-inside: avoid;
+ white-space: pre-wrap;
+}
+
+.fa {
+ display: none !important;
+}
diff --git a/docs/book/book/css/variables.css b/docs/book/book/css/variables.css
new file mode 100644
index 000000000000..21bf8e55e0cd
--- /dev/null
+++ b/docs/book/book/css/variables.css
@@ -0,0 +1,255 @@
+
+/* Globals */
+
+:root {
+ --sidebar-width: 300px;
+ --page-padding: 15px;
+ --content-max-width: 750px;
+ --menu-bar-height: 50px;
+ --mono-font: "Source Code Pro", Consolas, "Ubuntu Mono", Menlo, "DejaVu Sans Mono", monospace, monospace;
+ --code-font-size: 0.875em /* please adjust the ace font size accordingly in editor.js */
+}
+
+/* Themes */
+
+.ayu {
+ --bg: hsl(210, 25%, 8%);
+ --fg: #c5c5c5;
+
+ --sidebar-bg: #14191f;
+ --sidebar-fg: #c8c9db;
+ --sidebar-non-existant: #5c6773;
+ --sidebar-active: #ffb454;
+ --sidebar-spacer: #2d334f;
+
+ --scrollbar: var(--sidebar-fg);
+
+ --icons: #737480;
+ --icons-hover: #b7b9cc;
+
+ --links: #0096cf;
+
+ --inline-code-color: #ffb454;
+
+ --theme-popup-bg: #14191f;
+ --theme-popup-border: #5c6773;
+ --theme-hover: #191f26;
+
+ --quote-bg: hsl(226, 15%, 17%);
+ --quote-border: hsl(226, 15%, 22%);
+
+ --table-border-color: hsl(210, 25%, 13%);
+ --table-header-bg: hsl(210, 25%, 28%);
+ --table-alternate-bg: hsl(210, 25%, 11%);
+
+ --searchbar-border-color: #848484;
+ --searchbar-bg: #424242;
+ --searchbar-fg: #fff;
+ --searchbar-shadow-color: #d4c89f;
+ --searchresults-header-fg: #666;
+ --searchresults-border-color: #888;
+ --searchresults-li-bg: #252932;
+ --search-mark-bg: #e3b171;
+}
+
+.coal {
+ --bg: hsl(200, 7%, 8%);
+ --fg: #98a3ad;
+
+ --sidebar-bg: #292c2f;
+ --sidebar-fg: #a1adb8;
+ --sidebar-non-existant: #505254;
+ --sidebar-active: #3473ad;
+ --sidebar-spacer: #393939;
+
+ --scrollbar: var(--sidebar-fg);
+
+ --icons: #43484d;
+ --icons-hover: #b3c0cc;
+
+ --links: #2b79a2;
+
+ --inline-code-color: #c5c8c6;
+
+ --theme-popup-bg: #141617;
+ --theme-popup-border: #43484d;
+ --theme-hover: #1f2124;
+
+ --quote-bg: hsl(234, 21%, 18%);
+ --quote-border: hsl(234, 21%, 23%);
+
+ --table-border-color: hsl(200, 7%, 13%);
+ --table-header-bg: hsl(200, 7%, 28%);
+ --table-alternate-bg: hsl(200, 7%, 11%);
+
+ --searchbar-border-color: #aaa;
+ --searchbar-bg: #b7b7b7;
+ --searchbar-fg: #000;
+ --searchbar-shadow-color: #aaa;
+ --searchresults-header-fg: #666;
+ --searchresults-border-color: #98a3ad;
+ --searchresults-li-bg: #2b2b2f;
+ --search-mark-bg: #355c7d;
+}
+
+.light {
+ --bg: hsl(0, 0%, 100%);
+ --fg: hsl(0, 0%, 0%);
+
+ --sidebar-bg: #fafafa;
+ --sidebar-fg: hsl(0, 0%, 0%);
+ --sidebar-non-existant: #aaaaaa;
+ --sidebar-active: #1f1fff;
+ --sidebar-spacer: #f4f4f4;
+
+ --scrollbar: #8F8F8F;
+
+ --icons: #747474;
+ --icons-hover: #000000;
+
+ --links: #20609f;
+
+ --inline-code-color: #301900;
+
+ --theme-popup-bg: #fafafa;
+ --theme-popup-border: #cccccc;
+ --theme-hover: #e6e6e6;
+
+ --quote-bg: hsl(197, 37%, 96%);
+ --quote-border: hsl(197, 37%, 91%);
+
+ --table-border-color: hsl(0, 0%, 95%);
+ --table-header-bg: hsl(0, 0%, 80%);
+ --table-alternate-bg: hsl(0, 0%, 97%);
+
+ --searchbar-border-color: #aaa;
+ --searchbar-bg: #fafafa;
+ --searchbar-fg: #000;
+ --searchbar-shadow-color: #aaa;
+ --searchresults-header-fg: #666;
+ --searchresults-border-color: #888;
+ --searchresults-li-bg: #e4f2fe;
+ --search-mark-bg: #a2cff5;
+}
+
+.navy {
+ --bg: hsl(226, 23%, 11%);
+ --fg: #bcbdd0;
+
+ --sidebar-bg: #282d3f;
+ --sidebar-fg: #c8c9db;
+ --sidebar-non-existant: #505274;
+ --sidebar-active: #2b79a2;
+ --sidebar-spacer: #2d334f;
+
+ --scrollbar: var(--sidebar-fg);
+
+ --icons: #737480;
+ --icons-hover: #b7b9cc;
+
+ --links: #2b79a2;
+
+ --inline-code-color: #c5c8c6;
+
+ --theme-popup-bg: #161923;
+ --theme-popup-border: #737480;
+ --theme-hover: #282e40;
+
+ --quote-bg: hsl(226, 15%, 17%);
+ --quote-border: hsl(226, 15%, 22%);
+
+ --table-border-color: hsl(226, 23%, 16%);
+ --table-header-bg: hsl(226, 23%, 31%);
+ --table-alternate-bg: hsl(226, 23%, 14%);
+
+ --searchbar-border-color: #aaa;
+ --searchbar-bg: #aeaec6;
+ --searchbar-fg: #000;
+ --searchbar-shadow-color: #aaa;
+ --searchresults-header-fg: #5f5f71;
+ --searchresults-border-color: #5c5c68;
+ --searchresults-li-bg: #242430;
+ --search-mark-bg: #a2cff5;
+}
+
+.rust {
+ --bg: hsl(60, 9%, 87%);
+ --fg: #262625;
+
+ --sidebar-bg: #3b2e2a;
+ --sidebar-fg: #c8c9db;
+ --sidebar-non-existant: #505254;
+ --sidebar-active: #e69f67;
+ --sidebar-spacer: #45373a;
+
+ --scrollbar: var(--sidebar-fg);
+
+ --icons: #737480;
+ --icons-hover: #262625;
+
+ --links: #2b79a2;
+
+ --inline-code-color: #6e6b5e;
+
+ --theme-popup-bg: #e1e1db;
+ --theme-popup-border: #b38f6b;
+ --theme-hover: #99908a;
+
+ --quote-bg: hsl(60, 5%, 75%);
+ --quote-border: hsl(60, 5%, 70%);
+
+ --table-border-color: hsl(60, 9%, 82%);
+ --table-header-bg: #b3a497;
+ --table-alternate-bg: hsl(60, 9%, 84%);
+
+ --searchbar-border-color: #aaa;
+ --searchbar-bg: #fafafa;
+ --searchbar-fg: #000;
+ --searchbar-shadow-color: #aaa;
+ --searchresults-header-fg: #666;
+ --searchresults-border-color: #888;
+ --searchresults-li-bg: #dec2a2;
+ --search-mark-bg: #e69f67;
+}
+
+@media (prefers-color-scheme: dark) {
+ .light.no-js {
+ --bg: hsl(200, 7%, 8%);
+ --fg: #98a3ad;
+
+ --sidebar-bg: #292c2f;
+ --sidebar-fg: #a1adb8;
+ --sidebar-non-existant: #505254;
+ --sidebar-active: #3473ad;
+ --sidebar-spacer: #393939;
+
+ --scrollbar: var(--sidebar-fg);
+
+ --icons: #43484d;
+ --icons-hover: #b3c0cc;
+
+ --links: #2b79a2;
+
+ --inline-code-color: #c5c8c6;
+
+ --theme-popup-bg: #141617;
+ --theme-popup-border: #43484d;
+ --theme-hover: #1f2124;
+
+ --quote-bg: hsl(234, 21%, 18%);
+ --quote-border: hsl(234, 21%, 23%);
+
+ --table-border-color: hsl(200, 7%, 13%);
+ --table-header-bg: hsl(200, 7%, 28%);
+ --table-alternate-bg: hsl(200, 7%, 11%);
+
+ --searchbar-border-color: #aaa;
+ --searchbar-bg: #b7b7b7;
+ --searchbar-fg: #000;
+ --searchbar-shadow-color: #aaa;
+ --searchresults-header-fg: #666;
+ --searchresults-border-color: #98a3ad;
+ --searchresults-li-bg: #2b2b2f;
+ --search-mark-bg: #355c7d;
+ }
+}
diff --git a/docs/book/book/diagnostics/index.html b/docs/book/book/diagnostics/index.html
new file mode 100644
index 000000000000..b79e11b1763e
--- /dev/null
+++ b/docs/book/book/diagnostics/index.html
@@ -0,0 +1,346 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Configuration
+Source: +config.rs
+The Installation section contains details on
+configuration for some of the editors. In general rust-analyzer is
+configured via LSP messages, which means that it’s up to the editor to
+decide on the exact format and location of configuration files.
Some clients, such as VS Code or COC plugin in
+Vim provide rust-analyzer specific configuration
+UIs. Others may require you to know a bit more about the interaction
+with rust-analyzer.
For the later category, it might help to know that the initial
+configuration is specified as a value of the initializationOptions
+field of the InitializeParams message, in the LSP
+protocol.
+The spec says that the field type is any?, but rust-analyzer is
+looking for a JSON object that is constructed using settings from the
+list below. Name of the setting, ignoring the rust-analyzer. prefix,
+is used as a path, and value of the setting becomes the JSON property
+value.
For example, a very common configuration is to enable proc-macro +support, can be achieved by sending this JSON:
+{
+ "cargo": {
+ "buildScripts": {
+ "enable": true,
+ },
+ },
+ "procMacro": {
+ "enable": true,
+ }
+}
+Please consult your editor’s documentation to learn more about how to +configure LSP +servers.
+To verify which configuration is actually used by rust-analyzer, set
+RA_LOG environment variable to rust_analyzer=info and look for
+config-related messages. Logs should show both the JSON that
+rust-analyzer sees as well as the updated config.
This is the list of config options rust-analyzer supports:
rust-analyzer.assist.emitMustUse (default: false)
+Whether to insert #[must_use] when generating as_ methods
+for enum variants.
rust-analyzer.assist.expressionFillDefault (default: "todo")
+Placeholder expression to use for missing expressions in assists.
+rust-analyzer.cachePriming.enable (default: true)
+Warm up caches on project load.
+rust-analyzer.cachePriming.numThreads (default: 0)
+How many worker threads to handle priming caches. The default 0 means to pick automatically.
rust-analyzer.cargo.autoreload (default: true)
+Automatically refresh project info via cargo metadata on
+Cargo.toml or .cargo/config.toml changes.
rust-analyzer.cargo.buildScripts.enable (default: true)
+Run build scripts (build.rs) for more precise code analysis.
rust-analyzer.cargo.buildScripts.invocationLocation (default: "workspace")
+Specifies the working directory for running build scripts.
+-
+
- "workspace": run build scripts for a workspace in the workspace's root directory.
+This is incompatible with
#rust-analyzer.cargo.buildScripts.invocationStrategy#set toonce.
+ - "root": run build scripts in the project's root directory.
+This config only has an effect when
#rust-analyzer.cargo.buildScripts.overrideCommand#+is set.
+
rust-analyzer.cargo.buildScripts.invocationStrategy (default: "per_workspace")
+Specifies the invocation strategy to use when running the build scripts command.
+If per_workspace is set, the command will be executed for each workspace.
+If once is set, the command will be executed once.
+This config only has an effect when #rust-analyzer.cargo.buildScripts.overrideCommand#
+is set.
rust-analyzer.cargo.buildScripts.overrideCommand (default: null)
+Override the command rust-analyzer uses to run build scripts and
+build procedural macros. The command is required to output json
+and should therefore include --message-format=json or a similar
+option.
If there are multiple linked projects/workspaces, this command is invoked for
+each of them, with the working directory being the workspace root
+(i.e., the folder containing the Cargo.toml). This can be overwritten
+by changing #rust-analyzer.cargo.buildScripts.invocationStrategy# and
+#rust-analyzer.cargo.buildScripts.invocationLocation#.
By default, a cargo invocation will be constructed for the configured +targets and features, with the following base command line:
+cargo check --quiet --workspace --message-format=json --all-targets
+.
+rust-analyzer.cargo.buildScripts.useRustcWrapper (default: true)
+Use RUSTC_WRAPPER=rust-analyzer when running build scripts to
+avoid checking unnecessary things.
rust-analyzer.cargo.cfgs (default: {})
+List of cfg options to enable with the given values.
+rust-analyzer.cargo.extraArgs (default: [])
+Extra arguments that are passed to every cargo invocation.
+rust-analyzer.cargo.extraEnv (default: {})
+Extra environment variables that will be set when running cargo, rustc +or other commands within the workspace. Useful for setting RUSTFLAGS.
+rust-analyzer.cargo.features (default: [])
+List of features to activate.
+Set this to "all" to pass --all-features to cargo.
rust-analyzer.cargo.noDefaultFeatures (default: false)
+Whether to pass --no-default-features to cargo.
rust-analyzer.cargo.sysroot (default: "discover")
+Relative path to the sysroot, or "discover" to try to automatically find it via +"rustc --print sysroot".
+Unsetting this disables sysroot loading.
+This option does not take effect until rust-analyzer is restarted.
+rust-analyzer.cargo.sysrootSrc (default: null)
+Relative path to the sysroot library sources. If left unset, this will default to
+{cargo.sysroot}/lib/rustlib/src/rust/library.
This option does not take effect until rust-analyzer is restarted.
+rust-analyzer.cargo.target (default: null)
+Compilation target override (target triple).
+rust-analyzer.cargo.unsetTest (default: ["core"])
+Unsets the implicit #[cfg(test)] for the specified crates.
rust-analyzer.checkOnSave (default: true)
+Run the check command for diagnostics on save.
+rust-analyzer.check.allTargets (default: true)
+Check all targets and tests (--all-targets).
rust-analyzer.check.command (default: "check")
+Cargo command to use for cargo check.
rust-analyzer.check.extraArgs (default: [])
+Extra arguments for cargo check.
rust-analyzer.check.extraEnv (default: {})
+Extra environment variables that will be set when running cargo check.
+Extends #rust-analyzer.cargo.extraEnv#.
rust-analyzer.check.features (default: null)
+List of features to activate. Defaults to
+#rust-analyzer.cargo.features#.
Set to "all" to pass --all-features to Cargo.
rust-analyzer.check.ignore (default: [])
+List of cargo check (or other command specified in check.command) diagnostics to ignore.
For example for cargo check: dead_code, unused_imports, unused_variables,...
rust-analyzer.check.invocationLocation (default: "workspace")
+Specifies the working directory for running checks.
+-
+
- "workspace": run checks for workspaces in the corresponding workspaces' root directories.
+This falls back to "root" if
#rust-analyzer.cargo.check.invocationStrategy#is set toonce.
+ - "root": run checks in the project's root directory.
+This config only has an effect when
#rust-analyzer.cargo.check.overrideCommand#+is set.
+
rust-analyzer.check.invocationStrategy (default: "per_workspace")
+Specifies the invocation strategy to use when running the check command.
+If per_workspace is set, the command will be executed for each workspace.
+If once is set, the command will be executed once.
+This config only has an effect when #rust-analyzer.cargo.check.overrideCommand#
+is set.
rust-analyzer.check.noDefaultFeatures (default: null)
+Whether to pass --no-default-features to Cargo. Defaults to
+#rust-analyzer.cargo.noDefaultFeatures#.
rust-analyzer.check.overrideCommand (default: null)
+Override the command rust-analyzer uses instead of cargo check for
+diagnostics on save. The command is required to output json and
+should therefore include --message-format=json or a similar option
+(if your client supports the colorDiagnosticOutput experimental
+capability, you can use --message-format=json-diagnostic-rendered-ansi).
If you're changing this because you're using some tool wrapping
+Cargo, you might also want to change
+#rust-analyzer.cargo.buildScripts.overrideCommand#.
If there are multiple linked projects/workspaces, this command is invoked for
+each of them, with the working directory being the workspace root
+(i.e., the folder containing the Cargo.toml). This can be overwritten
+by changing #rust-analyzer.cargo.check.invocationStrategy# and
+#rust-analyzer.cargo.check.invocationLocation#.
An example command would be:
+cargo check --workspace --message-format=json --all-targets
+.
+rust-analyzer.check.targets (default: null)
+Check for specific targets. Defaults to #rust-analyzer.cargo.target# if empty.
Can be a single target, e.g. "x86_64-unknown-linux-gnu" or a list of targets, e.g.
+["aarch64-apple-darwin", "x86_64-apple-darwin"].
Aliased as "checkOnSave.targets".
rust-analyzer.completion.autoimport.enable (default: true)
+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.
rust-analyzer.completion.autoself.enable (default: true)
+Toggles the additional completions that automatically show method calls and field accesses
+with self prefixed to them when inside a method.
rust-analyzer.completion.callable.snippets (default: "fill_arguments")
+Whether to add parenthesis and argument snippets when completing function.
+rust-analyzer.completion.fullFunctionSignatures.enable (default: false)
+Whether to show full function/method signatures in completion docs.
+rust-analyzer.completion.limit (default: null)
+Maximum number of completions to return. If None, the limit is infinite.
rust-analyzer.completion.postfix.enable (default: true)
+Whether to show postfix snippets like dbg, if, not, etc.
rust-analyzer.completion.privateEditable.enable (default: false)
+Enables completions of private items and fields that are defined in the current workspace even if they are not visible at the current position.
+rust-analyzer.completion.snippets.custom
+Default:
+ "Arc::new": {
+ "postfix": "arc",
+ "body": "Arc::new(${receiver})",
+ "requires": "std::sync::Arc",
+ "description": "Put the expression into an `Arc`",
+ "scope": "expr"
+ },
+ "Rc::new": {
+ "postfix": "rc",
+ "body": "Rc::new(${receiver})",
+ "requires": "std::rc::Rc",
+ "description": "Put the expression into an `Rc`",
+ "scope": "expr"
+ },
+ "Box::pin": {
+ "postfix": "pinbox",
+ "body": "Box::pin(${receiver})",
+ "requires": "std::boxed::Box",
+ "description": "Put the expression into a pinned `Box`",
+ "scope": "expr"
+ },
+ "Ok": {
+ "postfix": "ok",
+ "body": "Ok(${receiver})",
+ "description": "Wrap the expression in a `Result::Ok`",
+ "scope": "expr"
+ },
+ "Err": {
+ "postfix": "err",
+ "body": "Err(${receiver})",
+ "description": "Wrap the expression in a `Result::Err`",
+ "scope": "expr"
+ },
+ "Some": {
+ "postfix": "some",
+ "body": "Some(${receiver})",
+ "description": "Wrap the expression in an `Option::Some`",
+ "scope": "expr"
+ }
+ }
+
+Custom completion snippets.
+rust-analyzer.diagnostics.disabled (default: [])
+List of rust-analyzer diagnostics to disable.
+rust-analyzer.diagnostics.enable (default: true)
+Whether to show native rust-analyzer diagnostics.
+rust-analyzer.diagnostics.experimental.enable (default: false)
+Whether to show experimental rust-analyzer diagnostics that might +have more false positives than usual.
+rust-analyzer.diagnostics.remapPrefix (default: {})
+Map of prefixes to be substituted when parsing diagnostic file paths.
+This should be the reverse mapping of what is passed to rustc as --remap-path-prefix.
rust-analyzer.diagnostics.warningsAsHint (default: [])
+List of warnings that should be displayed with hint severity.
+The warnings will be indicated by faded text or three dots in code
+and will not show up in the Problems Panel.
rust-analyzer.diagnostics.warningsAsInfo (default: [])
+List of warnings that should be displayed with info severity.
+The warnings will be indicated by a blue squiggly underline in code
+and a blue icon in the Problems Panel.
rust-analyzer.files.excludeDirs (default: [])
+These directories will be ignored by rust-analyzer. They are
+relative to the workspace root, and globs are not supported. You may
+also need to add the folders to Code's files.watcherExclude.
rust-analyzer.files.watcher (default: "client")
+Controls file watching implementation.
+rust-analyzer.highlightRelated.breakPoints.enable (default: true)
+Enables highlighting of related references while the cursor is on break, loop, while, or for keywords.
rust-analyzer.highlightRelated.closureCaptures.enable (default: true)
+Enables highlighting of all captures of a closure while the cursor is on the | or move keyword of a closure.
rust-analyzer.highlightRelated.exitPoints.enable (default: true)
+Enables highlighting of all exit points while the cursor is on any return, ?, fn, or return type arrow (->).
rust-analyzer.highlightRelated.references.enable (default: true)
+Enables highlighting of related references while the cursor is on any identifier.
+rust-analyzer.highlightRelated.yieldPoints.enable (default: true)
+Enables highlighting of all break points for a loop or block context while the cursor is on any async or await keywords.
rust-analyzer.hover.actions.debug.enable (default: true)
+Whether to show Debug action. Only applies when
+#rust-analyzer.hover.actions.enable# is set.
rust-analyzer.hover.actions.enable (default: true)
+Whether to show HoverActions in Rust files.
+rust-analyzer.hover.actions.gotoTypeDef.enable (default: true)
+Whether to show Go to Type Definition action. Only applies when
+#rust-analyzer.hover.actions.enable# is set.
rust-analyzer.hover.actions.implementations.enable (default: true)
+Whether to show Implementations action. Only applies when
+#rust-analyzer.hover.actions.enable# is set.
rust-analyzer.hover.actions.references.enable (default: false)
+Whether to show References action. Only applies when
+#rust-analyzer.hover.actions.enable# is set.
rust-analyzer.hover.actions.run.enable (default: true)
+Whether to show Run action. Only applies when
+#rust-analyzer.hover.actions.enable# is set.
rust-analyzer.hover.documentation.enable (default: true)
+Whether to show documentation on hover.
+rust-analyzer.hover.documentation.keywords.enable (default: true)
+Whether to show keyword hover popups. Only applies when
+#rust-analyzer.hover.documentation.enable# is set.
rust-analyzer.hover.links.enable (default: true)
+Use markdown syntax for links on hover.
+rust-analyzer.hover.memoryLayout.alignment (default: "hexadecimal")
+How to render the align information in a memory layout hover.
+rust-analyzer.hover.memoryLayout.enable (default: true)
+Whether to show memory layout data on hover.
+rust-analyzer.hover.memoryLayout.niches (default: false)
+How to render the niche information in a memory layout hover.
+rust-analyzer.hover.memoryLayout.offset (default: "hexadecimal")
+How to render the offset information in a memory layout hover.
+rust-analyzer.hover.memoryLayout.size (default: "both")
+How to render the size information in a memory layout hover.
+rust-analyzer.imports.granularity.enforce (default: false)
+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.
+rust-analyzer.imports.granularity.group (default: "crate")
+How imports should be grouped into use statements.
+rust-analyzer.imports.group.enable (default: true)
+Group inserted imports by the following order. Groups are separated by newlines.
+rust-analyzer.imports.merge.glob (default: true)
+Whether to allow import insertion to merge new imports into single path glob imports like use std::fmt::*;.
rust-analyzer.imports.prefer.no.std (default: false)
+Prefer to unconditionally use imports of the core and alloc crate, over the std crate.
+rust-analyzer.imports.prefix (default: "plain")
+The path structure for newly inserted paths to use.
+rust-analyzer.inlayHints.bindingModeHints.enable (default: false)
+Whether to show inlay type hints for binding modes.
+rust-analyzer.inlayHints.chainingHints.enable (default: true)
+Whether to show inlay type hints for method chains.
+rust-analyzer.inlayHints.closingBraceHints.enable (default: true)
+Whether to show inlay hints after a closing } to indicate what item it belongs to.
rust-analyzer.inlayHints.closingBraceHints.minLines (default: 25)
+Minimum number of lines required before the } until the hint is shown (set to 0 or 1
+to always show them).
rust-analyzer.inlayHints.closureCaptureHints.enable (default: false)
+Whether to show inlay hints for closure captures.
+rust-analyzer.inlayHints.closureReturnTypeHints.enable (default: "never")
+Whether to show inlay type hints for return types of closures.
+rust-analyzer.inlayHints.closureStyle (default: "impl_fn")
+Closure notation in type and chaining inlay hints.
+rust-analyzer.inlayHints.discriminantHints.enable (default: "never")
+Whether to show enum variant discriminant hints.
+rust-analyzer.inlayHints.expressionAdjustmentHints.enable (default: "never")
+Whether to show inlay hints for type adjustments.
+rust-analyzer.inlayHints.expressionAdjustmentHints.hideOutsideUnsafe (default: false)
+Whether to hide inlay hints for type adjustments outside of unsafe blocks.
rust-analyzer.inlayHints.expressionAdjustmentHints.mode (default: "prefix")
+Whether to show inlay hints as postfix ops (.* instead of *, etc).
rust-analyzer.inlayHints.lifetimeElisionHints.enable (default: "never")
+Whether to show inlay type hints for elided lifetimes in function signatures.
+rust-analyzer.inlayHints.lifetimeElisionHints.useParameterNames (default: false)
+Whether to prefer using parameter names as the name for elided lifetime hints if possible.
+rust-analyzer.inlayHints.maxLength (default: 25)
+Maximum length for inlay hints. Set to null to have an unlimited length.
+rust-analyzer.inlayHints.parameterHints.enable (default: true)
+Whether to show function parameter name inlay hints at the call +site.
+rust-analyzer.inlayHints.reborrowHints.enable (default: "never")
+Whether to show inlay hints for compiler inserted reborrows. +This setting is deprecated in favor of #rust-analyzer.inlayHints.expressionAdjustmentHints.enable#.
+rust-analyzer.inlayHints.renderColons (default: true)
+Whether to render leading colons for type hints, and trailing colons for parameter hints.
+rust-analyzer.inlayHints.typeHints.enable (default: true)
+Whether to show inlay type hints for variables.
+rust-analyzer.inlayHints.typeHints.hideClosureInitialization (default: false)
+Whether to hide inlay type hints for let statements that initialize to a closure.
+Only applies to closures with blocks, same as #rust-analyzer.inlayHints.closureReturnTypeHints.enable#.
rust-analyzer.inlayHints.typeHints.hideNamedConstructor (default: false)
+Whether to hide inlay type hints for constructors.
+rust-analyzer.interpret.tests (default: false)
+Enables the experimental support for interpreting tests.
+rust-analyzer.joinLines.joinAssignments (default: true)
+Join lines merges consecutive declaration and initialization of an assignment.
+rust-analyzer.joinLines.joinElseIf (default: true)
+Join lines inserts else between consecutive ifs.
+rust-analyzer.joinLines.removeTrailingComma (default: true)
+Join lines removes trailing commas.
+rust-analyzer.joinLines.unwrapTrivialBlock (default: true)
+Join lines unwraps trivial blocks.
+rust-analyzer.lens.debug.enable (default: true)
+Whether to show Debug lens. Only applies when
+#rust-analyzer.lens.enable# is set.
rust-analyzer.lens.enable (default: true)
+Whether to show CodeLens in Rust files.
+rust-analyzer.lens.forceCustomCommands (default: true)
+Internal config: use custom client-side commands even when the +client doesn't set the corresponding capability.
+rust-analyzer.lens.implementations.enable (default: true)
+Whether to show Implementations lens. Only applies when
+#rust-analyzer.lens.enable# is set.
rust-analyzer.lens.location (default: "above_name")
+Where to render annotations.
+rust-analyzer.lens.references.adt.enable (default: false)
+Whether to show References lens for Struct, Enum, and Union.
+Only applies when #rust-analyzer.lens.enable# is set.
rust-analyzer.lens.references.enumVariant.enable (default: false)
+Whether to show References lens for Enum Variants.
+Only applies when #rust-analyzer.lens.enable# is set.
rust-analyzer.lens.references.method.enable (default: false)
+Whether to show Method References lens. Only applies when
+#rust-analyzer.lens.enable# is set.
rust-analyzer.lens.references.trait.enable (default: false)
+Whether to show References lens for Trait.
+Only applies when #rust-analyzer.lens.enable# is set.
rust-analyzer.lens.run.enable (default: true)
+Whether to show Run lens. Only applies when
+#rust-analyzer.lens.enable# is set.
rust-analyzer.linkedProjects (default: [])
+Disable project auto-discovery in favor of explicitly specified set +of projects.
+Elements must be paths pointing to Cargo.toml,
+rust-project.json, or JSON objects in rust-project.json format.
rust-analyzer.lru.capacity (default: null)
+Number of syntax trees rust-analyzer keeps in memory. Defaults to 128.
+rust-analyzer.lru.query.capacities (default: {})
+Sets the LRU capacity of the specified queries.
+rust-analyzer.notifications.cargoTomlNotFound (default: true)
+Whether to show can't find Cargo.toml error message.
rust-analyzer.numThreads (default: null)
+How many worker threads in the main loop. The default null means to pick automatically.
rust-analyzer.procMacro.attributes.enable (default: true)
+Expand attribute macros. Requires #rust-analyzer.procMacro.enable# to be set.
rust-analyzer.procMacro.enable (default: true)
+Enable support for procedural macros, implies #rust-analyzer.cargo.buildScripts.enable#.
rust-analyzer.procMacro.ignored (default: {})
+These proc-macros will be ignored when trying to expand them.
+This config takes a map of crate names with the exported proc-macro names to ignore as values.
+rust-analyzer.procMacro.server (default: null)
+Internal config, path to proc-macro server executable.
+rust-analyzer.references.excludeImports (default: false)
+Exclude imports from find-all-references.
+rust-analyzer.runnables.command (default: null)
+Command to be executed instead of 'cargo' for runnables.
+rust-analyzer.runnables.extraArgs (default: [])
+Additional arguments to be passed to cargo for runnables such as
+tests or binaries. For example, it may be --release.
rust-analyzer.rust.analyzerTargetDir (default: null)
+Optional path to a rust-analyzer specific target directory.
+This prevents rust-analyzer's cargo check from locking the Cargo.lock
+at the expense of duplicating build artifacts.
Set to true to use a subdirectory of the existing target directory or
+set to a path relative to the workspace to use that path.
rust-analyzer.rustc.source (default: null)
+Path to the Cargo.toml of the rust compiler workspace, for usage in rustc_private
+projects, or "discover" to try to automatically find it if the rustc-dev component
+is installed.
Any project which uses rust-analyzer with the rustcPrivate
+crates must set [package.metadata.rust-analyzer] rustc_private=true to use it.
This option does not take effect until rust-analyzer is restarted.
+rust-analyzer.rustfmt.extraArgs (default: [])
+Additional arguments to rustfmt.
rust-analyzer.rustfmt.overrideCommand (default: null)
+Advanced option, fully override the command rust-analyzer uses for
+formatting. This should be the equivalent of rustfmt here, and
+not that of cargo fmt. The file contents will be passed on the
+standard input and the formatted result will be read from the
+standard output.
rust-analyzer.rustfmt.rangeFormatting.enable (default: false)
+Enables the use of rustfmt's unstable range formatting command for the
+textDocument/rangeFormatting request. The rustfmt option is unstable and only
+available on a nightly build.
rust-analyzer.semanticHighlighting.doc.comment.inject.enable (default: true)
+Inject additional highlighting into doc comments.
+When enabled, rust-analyzer will highlight rust source in doc comments as well as intra +doc links.
+rust-analyzer.semanticHighlighting.nonStandardTokens (default: true)
+Whether the server is allowed to emit non-standard tokens and modifiers.
+rust-analyzer.semanticHighlighting.operator.enable (default: true)
+Use semantic tokens for operators.
+When disabled, rust-analyzer will emit semantic tokens only for operator tokens when +they are tagged with modifiers.
+rust-analyzer.semanticHighlighting.operator.specialization.enable (default: false)
+Use specialized semantic tokens for operators.
+When enabled, rust-analyzer will emit special token types for operator tokens instead
+of the generic operator token type.
rust-analyzer.semanticHighlighting.punctuation.enable (default: false)
+Use semantic tokens for punctuation.
+When disabled, rust-analyzer will emit semantic tokens only for punctuation tokens when +they are tagged with modifiers or have a special role.
+rust-analyzer.semanticHighlighting.punctuation.separate.macro.bang (default: false)
+When enabled, rust-analyzer will emit a punctuation semantic token for the ! of macro
+calls.
rust-analyzer.semanticHighlighting.punctuation.specialization.enable (default: false)
+Use specialized semantic tokens for punctuation.
+When enabled, rust-analyzer will emit special token types for punctuation tokens instead
+of the generic punctuation token type.
rust-analyzer.semanticHighlighting.strings.enable (default: true)
+Use semantic tokens for strings.
+In some editors (e.g. vscode) semantic tokens override other highlighting grammars. +By disabling semantic tokens for strings, other grammars can be used to highlight +their contents.
+rust-analyzer.signatureInfo.detail (default: "full")
+Show full signature of the callable. Only shows parameters if disabled.
+rust-analyzer.signatureInfo.documentation.enable (default: true)
+Show documentation.
+rust-analyzer.typing.autoClosingAngleBrackets.enable (default: false)
+Whether to insert closing angle brackets when typing an opening angle bracket of a generic argument list.
+rust-analyzer.workspace.symbol.search.kind (default: "only_types")
+Workspace symbol search kind.
+rust-analyzer.workspace.symbol.search.limit (default: 128)
+Limits the number of items returned from a workspace symbol search (Defaults to 128). +Some clients like vs-code issue new searches on result filtering and don't require all results to be returned in the initial search. +Other clients requires all results upfront and might require a higher limit.
+rust-analyzer.workspace.symbol.search.scope (default: "workspace")
+Workspace symbol search scope.
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/book/book/editor.js b/docs/book/book/editor.js
new file mode 100644
index 000000000000..464790c49932
--- /dev/null
+++ b/docs/book/book/editor.js
@@ -0,0 +1,29 @@
+"use strict";
+window.editors = [];
+(function(editors) {
+ if (typeof(ace) === 'undefined' || !ace) {
+ return;
+ }
+
+ Array.from(document.querySelectorAll('.editable')).forEach(function(editable) {
+ let display_line_numbers = window.playground_line_numbers || false;
+
+ let editor = ace.edit(editable);
+ editor.setOptions({
+ highlightActiveLine: false,
+ showPrintMargin: false,
+ showLineNumbers: display_line_numbers,
+ showGutter: display_line_numbers,
+ maxLines: Infinity,
+ fontSize: "0.875em" // please adjust the font size of the code in general.css
+ });
+
+ editor.$blockScrolling = Infinity;
+
+ editor.getSession().setMode("ace/mode/rust");
+
+ editor.originalCode = editor.getValue();
+
+ editors.push(editor);
+ });
+})(window.editors);
diff --git a/docs/book/book/editor_features/index.html b/docs/book/book/editor_features/index.html
new file mode 100644
index 000000000000..721922872b1b
--- /dev/null
+++ b/docs/book/book/editor_features/index.html
@@ -0,0 +1,368 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Diagnostics
+While most errors and warnings provided by rust-analyzer come from the
+cargo check integration, there’s a growing number of diagnostics
+implemented using rust-analyzer’s own analysis. Some of these
+diagnostics don’t respect #[allow] or \#[deny] attributes yet, but
+can be turned off using the rust-analyzer.diagnostics.enable,
+rust-analyzer.diagnostics.experimental.enable or
+rust-analyzer.diagnostics.disabled settings.
Clippy
+To run cargo clippy instead of cargo check, you can set
+"rust-analyzer.check.command": "clippy".
break-outside-of-loop
+Source: break_outside_of_loop.rs
+This diagnostic is triggered if the break keyword is used outside of a loop.
expected-function
+Source: expected_function.rs
+This diagnostic is triggered if a call is made on something that is not callable.
+inactive-code
+Source: inactive_code.rs
+This diagnostic is shown for code with inactive #[cfg] attributes.
incoherent-impl
+Source: incoherent_impl.rs
+This diagnostic is triggered if the targe type of an impl is from a foreign crate.
+incorrect-ident-case
+Source: incorrect_case.rs
+This diagnostic is triggered if an item name doesn't follow Rust naming convention.
+invalid-derive-target
+Source: invalid_derive_target.rs
+This diagnostic is shown when the derive attribute is used on an item other than a struct,
+enum or union.
macro-error
+Source: macro_error.rs
+This diagnostic is shown for macro expansion errors.
+macro-error
+Source: macro_error.rs
+This diagnostic is shown for macro expansion errors.
+malformed-derive
+Source: malformed_derive.rs
+This diagnostic is shown when the derive attribute has invalid input.
+mismatched-arg-count
+Source: mismatched_arg_count.rs
+This diagnostic is triggered if a function is invoked with an incorrect amount of arguments.
+mismatched-tuple-struct-pat-arg-count
+Source: mismatched_arg_count.rs
+This diagnostic is triggered if a function is invoked with an incorrect amount of arguments.
+missing-fields
+Source: missing_fields.rs
+This diagnostic is triggered if record lacks some fields that exist in the corresponding structure.
+Example:
+struct A { a: u8, b: u8 }
+
+let a = A { a: 10 };missing-match-arm
+Source: missing_match_arms.rs
+This diagnostic is triggered if match block is missing one or more match arms.
missing-unsafe
+Source: missing_unsafe.rs
+This diagnostic is triggered if an operation marked as unsafe is used outside of an unsafe function or block.
moved-out-of-ref
+Source: moved_out_of_ref.rs
+This diagnostic is triggered on moving non copy things out of references.
+need-mut
+Source: mutability_errors.rs
+This diagnostic is triggered on mutating an immutable variable.
+no-such-field
+Source: no_such_field.rs
+This diagnostic is triggered if created structure does not have field provided in record.
+private-assoc-item
+Source: private_assoc_item.rs
+This diagnostic is triggered if the referenced associated item is not visible from the current +module.
+private-field
+Source: private_field.rs
+This diagnostic is triggered if the accessed field is not visible from the current module.
+replace-filter-map-next-with-find-map
+Source: replace_filter_map_next_with_find_map.rs
+This diagnostic is triggered when .filter_map(..).next() is used, rather than the more concise .find_map(..).
type-mismatch
+Source: type_mismatch.rs
+This diagnostic is triggered when the type of an expression or pattern does not match +the expected type.
+typed-hole
+Source: typed_hole.rs
+This diagnostic is triggered when an underscore expression is used in an invalid position.
+undeclared-label
+Source: undeclared_label.rs
+unimplemented-builtin-macro
+Source: unimplemented_builtin_macro.rs
+This diagnostic is shown for builtin macros which are not yet implemented by rust-analyzer
+unlinked-file
+Source: unlinked_file.rs
+This diagnostic is shown for files that are not included in any crate, or files that are part of +crates rust-analyzer failed to discover. The file will not have IDE features available.
+unnecessary-braces
+Source: useless_braces.rs
+Diagnostic for unnecessary braces in use items.
unreachable-label
+Source: unreachable_label.rs
+unresolved-extern-crate
+Source: unresolved_extern_crate.rs
+This diagnostic is triggered if rust-analyzer is unable to discover referred extern crate.
+unresolved-field
+Source: unresolved_field.rs
+This diagnostic is triggered if a field does not exist on a given type.
+unresolved-import
+Source: unresolved_import.rs
+This diagnostic is triggered if rust-analyzer is unable to resolve a path in
+a use declaration.
unresolved-macro-call
+Source: unresolved_macro_call.rs
+This diagnostic is triggered if rust-analyzer is unable to resolve the path +to a macro in a macro invocation.
+unresolved-method
+Source: unresolved_method.rs
+This diagnostic is triggered if a method does not exist on a given type.
+unresolved-module
+Source: unresolved_module.rs
+This diagnostic is triggered if rust-analyzer is unable to discover referred module.
+unresolved-proc-macro
+Source: unresolved_proc_macro.rs
+This diagnostic is shown when a procedural macro can not be found. This usually means that +procedural macro support is simply disabled (and hence is only a weak hint instead of an error), +but can also indicate project setup problems.
+If you are seeing a lot of "proc macro not expanded" warnings, you can add this option to the
+rust-analyzer.diagnostics.disabled list to prevent them from showing. Alternatively you can
+enable support for procedural macros (see rust-analyzer.procMacro.attributes.enable).
unused-mut
+Source: mutability_errors.rs
+This diagnostic is triggered when a mutable variable isn't actually mutated.
+unused-variables
+Source: unused_variables.rs
+This diagnostic is triggered when a local variable is not used.
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/book/book/elasticlunr.min.js b/docs/book/book/elasticlunr.min.js
new file mode 100644
index 000000000000..94b20dd2ef46
--- /dev/null
+++ b/docs/book/book/elasticlunr.min.js
@@ -0,0 +1,10 @@
+/**
+ * elasticlunr - http://weixsong.github.io
+ * Lightweight full-text search engine in Javascript for browser search and offline search. - 0.9.5
+ *
+ * Copyright (C) 2017 Oliver Nightingale
+ * Copyright (C) 2017 Wei Song
+ * MIT Licensed
+ * @license
+ */
+!function(){function e(e){if(null===e||"object"!=typeof e)return e;var t=e.constructor();for(var n in e)e.hasOwnProperty(n)&&(t[n]=e[n]);return t}var t=function(e){var n=new t.Index;return n.pipeline.add(t.trimmer,t.stopWordFilter,t.stemmer),e&&e.call(n,n),n};t.version="0.9.5",lunr=t,t.utils={},t.utils.warn=function(e){return function(t){e.console&&console.warn&&console.warn(t)}}(this),t.utils.toString=function(e){return void 0===e||null===e?"":e.toString()},t.EventEmitter=function(){this.events={}},t.EventEmitter.prototype.addListener=function(){var e=Array.prototype.slice.call(arguments),t=e.pop(),n=e;if("function"!=typeof t)throw new TypeError("last argument must be a function");n.forEach(function(e){this.hasHandler(e)||(this.events[e]=[]),this.events[e].push(t)},this)},t.EventEmitter.prototype.removeListener=function(e,t){if(this.hasHandler(e)){var n=this.events[e].indexOf(t);-1!==n&&(this.events[e].splice(n,1),0==this.events[e].length&&delete this.events[e])}},t.EventEmitter.prototype.emit=function(e){if(this.hasHandler(e)){var t=Array.prototype.slice.call(arguments,1);this.events[e].forEach(function(e){e.apply(void 0,t)},this)}},t.EventEmitter.prototype.hasHandler=function(e){return e in this.events},t.tokenizer=function(e){if(!arguments.length||null===e||void 0===e)return[];if(Array.isArray(e)){var n=e.filter(function(e){return null===e||void 0===e?!1:!0});n=n.map(function(e){return t.utils.toString(e).toLowerCase()});var i=[];return n.forEach(function(e){var n=e.split(t.tokenizer.seperator);i=i.concat(n)},this),i}return e.toString().trim().toLowerCase().split(t.tokenizer.seperator)},t.tokenizer.defaultSeperator=/[\s\-]+/,t.tokenizer.seperator=t.tokenizer.defaultSeperator,t.tokenizer.setSeperator=function(e){null!==e&&void 0!==e&&"object"==typeof e&&(t.tokenizer.seperator=e)},t.tokenizer.resetSeperator=function(){t.tokenizer.seperator=t.tokenizer.defaultSeperator},t.tokenizer.getSeperator=function(){return t.tokenizer.seperator},t.Pipeline=function(){this._queue=[]},t.Pipeline.registeredFunctions={},t.Pipeline.registerFunction=function(e,n){n in t.Pipeline.registeredFunctions&&t.utils.warn("Overwriting existing registered function: "+n),e.label=n,t.Pipeline.registeredFunctions[n]=e},t.Pipeline.getRegisteredFunction=function(e){return e in t.Pipeline.registeredFunctions!=!0?null:t.Pipeline.registeredFunctions[e]},t.Pipeline.warnIfFunctionNotRegistered=function(e){var n=e.label&&e.label in this.registeredFunctions;n||t.utils.warn("Function is not registered with pipeline. This may cause problems when serialising the index.\n",e)},t.Pipeline.load=function(e){var n=new t.Pipeline;return e.forEach(function(e){var i=t.Pipeline.getRegisteredFunction(e);if(!i)throw new Error("Cannot load un-registered function: "+e);n.add(i)}),n},t.Pipeline.prototype.add=function(){var e=Array.prototype.slice.call(arguments);e.forEach(function(e){t.Pipeline.warnIfFunctionNotRegistered(e),this._queue.push(e)},this)},t.Pipeline.prototype.after=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._queue.indexOf(e);if(-1===i)throw new Error("Cannot find existingFn");this._queue.splice(i+1,0,n)},t.Pipeline.prototype.before=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._queue.indexOf(e);if(-1===i)throw new Error("Cannot find existingFn");this._queue.splice(i,0,n)},t.Pipeline.prototype.remove=function(e){var t=this._queue.indexOf(e);-1!==t&&this._queue.splice(t,1)},t.Pipeline.prototype.run=function(e){for(var t=[],n=e.length,i=this._queue.length,o=0;n>o;o++){for(var r=e[o],s=0;i>s&&(r=this._queue[s](r,o,e),void 0!==r&&null!==r);s++);void 0!==r&&null!==r&&t.push(r)}return t},t.Pipeline.prototype.reset=function(){this._queue=[]},t.Pipeline.prototype.get=function(){return this._queue},t.Pipeline.prototype.toJSON=function(){return this._queue.map(function(e){return t.Pipeline.warnIfFunctionNotRegistered(e),e.label})},t.Index=function(){this._fields=[],this._ref="id",this.pipeline=new t.Pipeline,this.documentStore=new t.DocumentStore,this.index={},this.eventEmitter=new t.EventEmitter,this._idfCache={},this.on("add","remove","update",function(){this._idfCache={}}.bind(this))},t.Index.prototype.on=function(){var e=Array.prototype.slice.call(arguments);return this.eventEmitter.addListener.apply(this.eventEmitter,e)},t.Index.prototype.off=function(e,t){return this.eventEmitter.removeListener(e,t)},t.Index.load=function(e){e.version!==t.version&&t.utils.warn("version mismatch: current "+t.version+" importing "+e.version);var n=new this;n._fields=e.fields,n._ref=e.ref,n.documentStore=t.DocumentStore.load(e.documentStore),n.pipeline=t.Pipeline.load(e.pipeline),n.index={};for(var i in e.index)n.index[i]=t.InvertedIndex.load(e.index[i]);return n},t.Index.prototype.addField=function(e){return this._fields.push(e),this.index[e]=new t.InvertedIndex,this},t.Index.prototype.setRef=function(e){return this._ref=e,this},t.Index.prototype.saveDocument=function(e){return this.documentStore=new t.DocumentStore(e),this},t.Index.prototype.addDoc=function(e,n){if(e){var n=void 0===n?!0:n,i=e[this._ref];this.documentStore.addDoc(i,e),this._fields.forEach(function(n){var o=this.pipeline.run(t.tokenizer(e[n]));this.documentStore.addFieldLength(i,n,o.length);var r={};o.forEach(function(e){e in r?r[e]+=1:r[e]=1},this);for(var s in r){var u=r[s];u=Math.sqrt(u),this.index[n].addToken(s,{ref:i,tf:u})}},this),n&&this.eventEmitter.emit("add",e,this)}},t.Index.prototype.removeDocByRef=function(e){if(e&&this.documentStore.isDocStored()!==!1&&this.documentStore.hasDoc(e)){var t=this.documentStore.getDoc(e);this.removeDoc(t,!1)}},t.Index.prototype.removeDoc=function(e,n){if(e){var n=void 0===n?!0:n,i=e[this._ref];this.documentStore.hasDoc(i)&&(this.documentStore.removeDoc(i),this._fields.forEach(function(n){var o=this.pipeline.run(t.tokenizer(e[n]));o.forEach(function(e){this.index[n].removeToken(e,i)},this)},this),n&&this.eventEmitter.emit("remove",e,this))}},t.Index.prototype.updateDoc=function(e,t){var t=void 0===t?!0:t;this.removeDocByRef(e[this._ref],!1),this.addDoc(e,!1),t&&this.eventEmitter.emit("update",e,this)},t.Index.prototype.idf=function(e,t){var n="@"+t+"/"+e;if(Object.prototype.hasOwnProperty.call(this._idfCache,n))return this._idfCache[n];var i=this.index[t].getDocFreq(e),o=1+Math.log(this.documentStore.length/(i+1));return this._idfCache[n]=o,o},t.Index.prototype.getFields=function(){return this._fields.slice()},t.Index.prototype.search=function(e,n){if(!e)return[];e="string"==typeof e?{any:e}:JSON.parse(JSON.stringify(e));var i=null;null!=n&&(i=JSON.stringify(n));for(var o=new t.Configuration(i,this.getFields()).get(),r={},s=Object.keys(e),u=0;u
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Special
+
+
+
+
+ Editor Features
+VS Code
+Color configurations
+It is possible to change the foreground/background color and font
+family/size of inlay hints. Just add this to your settings.json:
{
+ "editor.inlayHints.fontFamily": "Courier New",
+ "editor.inlayHints.fontSize": 11,
+
+ "workbench.colorCustomizations": {
+ // Name of the theme you are currently using
+ "[Default Dark+]": {
+ "editorInlayHint.foreground": "#868686f0",
+ "editorInlayHint.background": "#3d3d3d48",
+
+ // Overrides for specific kinds of inlay hints
+ "editorInlayHint.typeForeground": "#fdb6fdf0",
+ "editorInlayHint.parameterForeground": "#fdb6fdf0",
+ }
+ }
+}
+Semantic style customizations
+You can customize the look of different semantic elements in the source
+code. For example, mutable bindings are underlined by default and you
+can override this behavior by adding the following section to your
+settings.json:
{
+ "editor.semanticTokenColorCustomizations": {
+ "rules": {
+ "*.mutable": {
+ "fontStyle": "", // underline is the default
+ },
+ }
+ },
+}
+Most themes doesn’t support styling unsafe operations differently yet.
+You can fix this by adding overrides for the rules operator.unsafe,
+function.unsafe, and method.unsafe:
{
+ "editor.semanticTokenColorCustomizations": {
+ "rules": {
+ "operator.unsafe": "#ff6600",
+ "function.unsafe": "#ff6600",
+ "method.unsafe": "#ff6600"
+ }
+ },
+}
+In addition to the top-level rules you can specify overrides for +specific themes. For example, if you wanted to use a darker text color +on a specific light theme, you might write:
+{
+ "editor.semanticTokenColorCustomizations": {
+ "rules": {
+ "operator.unsafe": "#ff6600"
+ },
+ "[Ayu Light]": {
+ "rules": {
+ "operator.unsafe": "#572300"
+ }
+ }
+ },
+}
+Make sure you include the brackets around the theme name. For example,
+use "[Ayu Light]" to customize the theme Ayu Light.
Special when clause context for keybindings.
+You may use inRustProject context to configure keybindings for rust
+projects only. For example:
{
+ "key": "ctrl+alt+d",
+ "command": "rust-analyzer.openDocs",
+ "when": "inRustProject"
+}
+More about when clause contexts
+here.
Setting runnable environment variables
+You can use "rust-analyzer.runnables.extraEnv" setting to define +runnable environment-specific substitution variables. The simplest way +for all runnables in a bunch:
+"rust-analyzer.runnables.extraEnv": {
+ "RUN_SLOW_TESTS": "1"
+}
+Or it is possible to specify vars more granularly:
+"rust-analyzer.runnables.extraEnv": [
+ {
+ // "mask": null, // null mask means that this rule will be applied for all runnables
+ env: {
+ "APP_ID": "1",
+ "APP_DATA": "asdf"
+ }
+ },
+ {
+ "mask": "test_name",
+ "env": {
+ "APP_ID": "2", // overwrites only APP_ID
+ }
+ }
+]
+You can use any valid regular expression as a mask. Also note that a
+full runnable name is something like run bin_or_example_name,
+test some::mod::test_name or test-mod some::mod, so it is
+possible to distinguish binaries, single tests, and test modules with
+this masks: "^run", "^test " (the trailing space matters!), and
+"^test-mod" respectively.
If needed, you can set different values for different platforms:
+"rust-analyzer.runnables.extraEnv": [
+ {
+ "platform": "win32", // windows only
+ env: {
+ "APP_DATA": "windows specific data"
+ }
+ },
+ {
+ "platform": ["linux"],
+ "env": {
+ "APP_DATA": "linux data",
+ }
+ },
+ { // for all platforms
+ "env": {
+ "APP_COMMON_DATA": "xxx",
+ }
+ }
+]
+Compiler feedback from external commands
+Instead of relying on the built-in cargo check, you can configure Code
+to run a command in the background and use the $rustc-watch problem
+matcher to generate inline error markers from its output.
To do this you need to create a new VS Code
+Task and set
+"rust-analyzer.checkOnSave": false in preferences.
For example, if you want to run
+cargo watch instead, you might
+add the following to .vscode/tasks.json:
{
+ "label": "Watch",
+ "group": "build",
+ "type": "shell",
+ "command": "cargo watch",
+ "problemMatcher": "$rustc-watch",
+ "isBackground": true
+}
+Live Share
+VS Code Live Share has partial support for rust-analyzer.
+Live Share requires the official Microsoft build of VS Code, OSS +builds will not work correctly.
+The host’s rust-analyzer instance will be shared with all guests joining +the session. The guests do not have to have the rust-analyzer extension +installed for this to work.
+If you are joining a Live Share session and do have rust-analyzer +installed locally, commands from the command palette will not work +correctly since they will attempt to communicate with the local server.
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/book/book/fonts/OPEN-SANS-LICENSE.txt b/docs/book/book/fonts/OPEN-SANS-LICENSE.txt
new file mode 100644
index 000000000000..d64569567334
--- /dev/null
+++ b/docs/book/book/fonts/OPEN-SANS-LICENSE.txt
@@ -0,0 +1,202 @@
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
diff --git a/docs/book/book/fonts/SOURCE-CODE-PRO-LICENSE.txt b/docs/book/book/fonts/SOURCE-CODE-PRO-LICENSE.txt
new file mode 100644
index 000000000000..366206f54950
--- /dev/null
+++ b/docs/book/book/fonts/SOURCE-CODE-PRO-LICENSE.txt
@@ -0,0 +1,93 @@
+Copyright 2010, 2012 Adobe Systems Incorporated (http://www.adobe.com/), with Reserved Font Name 'Source'. All Rights Reserved. Source is a trademark of Adobe Systems Incorporated in the United States and/or other countries.
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
diff --git a/docs/book/book/fonts/fonts.css b/docs/book/book/fonts/fonts.css
new file mode 100644
index 000000000000..858efa59800b
--- /dev/null
+++ b/docs/book/book/fonts/fonts.css
@@ -0,0 +1,100 @@
+/* Open Sans is licensed under the Apache License, Version 2.0. See http://www.apache.org/licenses/LICENSE-2.0 */
+/* Source Code Pro is under the Open Font License. See https://scripts.sil.org/cms/scripts/page.php?site_id=nrsi&id=OFL */
+
+/* open-sans-300 - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: normal;
+ font-weight: 300;
+ src: local('Open Sans Light'), local('OpenSans-Light'),
+ url('open-sans-v17-all-charsets-300.woff2') format('woff2');
+}
+
+/* open-sans-300italic - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: italic;
+ font-weight: 300;
+ src: local('Open Sans Light Italic'), local('OpenSans-LightItalic'),
+ url('open-sans-v17-all-charsets-300italic.woff2') format('woff2');
+}
+
+/* open-sans-regular - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: normal;
+ font-weight: 400;
+ src: local('Open Sans Regular'), local('OpenSans-Regular'),
+ url('open-sans-v17-all-charsets-regular.woff2') format('woff2');
+}
+
+/* open-sans-italic - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: italic;
+ font-weight: 400;
+ src: local('Open Sans Italic'), local('OpenSans-Italic'),
+ url('open-sans-v17-all-charsets-italic.woff2') format('woff2');
+}
+
+/* open-sans-600 - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: normal;
+ font-weight: 600;
+ src: local('Open Sans SemiBold'), local('OpenSans-SemiBold'),
+ url('open-sans-v17-all-charsets-600.woff2') format('woff2');
+}
+
+/* open-sans-600italic - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: italic;
+ font-weight: 600;
+ src: local('Open Sans SemiBold Italic'), local('OpenSans-SemiBoldItalic'),
+ url('open-sans-v17-all-charsets-600italic.woff2') format('woff2');
+}
+
+/* open-sans-700 - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: normal;
+ font-weight: 700;
+ src: local('Open Sans Bold'), local('OpenSans-Bold'),
+ url('open-sans-v17-all-charsets-700.woff2') format('woff2');
+}
+
+/* open-sans-700italic - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: italic;
+ font-weight: 700;
+ src: local('Open Sans Bold Italic'), local('OpenSans-BoldItalic'),
+ url('open-sans-v17-all-charsets-700italic.woff2') format('woff2');
+}
+
+/* open-sans-800 - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: normal;
+ font-weight: 800;
+ src: local('Open Sans ExtraBold'), local('OpenSans-ExtraBold'),
+ url('open-sans-v17-all-charsets-800.woff2') format('woff2');
+}
+
+/* open-sans-800italic - latin_vietnamese_latin-ext_greek-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Open Sans';
+ font-style: italic;
+ font-weight: 800;
+ src: local('Open Sans ExtraBold Italic'), local('OpenSans-ExtraBoldItalic'),
+ url('open-sans-v17-all-charsets-800italic.woff2') format('woff2');
+}
+
+/* source-code-pro-500 - latin_vietnamese_latin-ext_greek_cyrillic-ext_cyrillic */
+@font-face {
+ font-family: 'Source Code Pro';
+ font-style: normal;
+ font-weight: 500;
+ src: url('source-code-pro-v11-all-charsets-500.woff2') format('woff2');
+}
diff --git a/docs/book/book/fonts/open-sans-v17-all-charsets-300.woff2 b/docs/book/book/fonts/open-sans-v17-all-charsets-300.woff2
new file mode 100644
index 000000000000..9f51be370fa9
Binary files /dev/null and b/docs/book/book/fonts/open-sans-v17-all-charsets-300.woff2 differ
diff --git a/docs/book/book/fonts/open-sans-v17-all-charsets-300italic.woff2 b/docs/book/book/fonts/open-sans-v17-all-charsets-300italic.woff2
new file mode 100644
index 000000000000..2f545448418c
Binary files /dev/null and b/docs/book/book/fonts/open-sans-v17-all-charsets-300italic.woff2 differ
diff --git a/docs/book/book/fonts/open-sans-v17-all-charsets-600.woff2 b/docs/book/book/fonts/open-sans-v17-all-charsets-600.woff2
new file mode 100644
index 000000000000..f503d558d58d
Binary files /dev/null and b/docs/book/book/fonts/open-sans-v17-all-charsets-600.woff2 differ
diff --git a/docs/book/book/fonts/open-sans-v17-all-charsets-600italic.woff2 b/docs/book/book/fonts/open-sans-v17-all-charsets-600italic.woff2
new file mode 100644
index 000000000000..c99aabe80340
Binary files /dev/null and b/docs/book/book/fonts/open-sans-v17-all-charsets-600italic.woff2 differ
diff --git a/docs/book/book/fonts/open-sans-v17-all-charsets-700.woff2 b/docs/book/book/fonts/open-sans-v17-all-charsets-700.woff2
new file mode 100644
index 000000000000..421a1ab25fa8
Binary files /dev/null and b/docs/book/book/fonts/open-sans-v17-all-charsets-700.woff2 differ
diff --git a/docs/book/book/fonts/open-sans-v17-all-charsets-700italic.woff2 b/docs/book/book/fonts/open-sans-v17-all-charsets-700italic.woff2
new file mode 100644
index 000000000000..12ce3d20d1ce
Binary files /dev/null and b/docs/book/book/fonts/open-sans-v17-all-charsets-700italic.woff2 differ
diff --git a/docs/book/book/fonts/open-sans-v17-all-charsets-800.woff2 b/docs/book/book/fonts/open-sans-v17-all-charsets-800.woff2
new file mode 100644
index 000000000000..c94a223b0332
Binary files /dev/null and b/docs/book/book/fonts/open-sans-v17-all-charsets-800.woff2 differ
diff --git a/docs/book/book/fonts/open-sans-v17-all-charsets-800italic.woff2 b/docs/book/book/fonts/open-sans-v17-all-charsets-800italic.woff2
new file mode 100644
index 000000000000..eed7d3c63d1f
Binary files /dev/null and b/docs/book/book/fonts/open-sans-v17-all-charsets-800italic.woff2 differ
diff --git a/docs/book/book/fonts/open-sans-v17-all-charsets-italic.woff2 b/docs/book/book/fonts/open-sans-v17-all-charsets-italic.woff2
new file mode 100644
index 000000000000..398b68a0853f
Binary files /dev/null and b/docs/book/book/fonts/open-sans-v17-all-charsets-italic.woff2 differ
diff --git a/docs/book/book/fonts/open-sans-v17-all-charsets-regular.woff2 b/docs/book/book/fonts/open-sans-v17-all-charsets-regular.woff2
new file mode 100644
index 000000000000..8383e94c6547
Binary files /dev/null and b/docs/book/book/fonts/open-sans-v17-all-charsets-regular.woff2 differ
diff --git a/docs/book/book/fonts/source-code-pro-v11-all-charsets-500.woff2 b/docs/book/book/fonts/source-code-pro-v11-all-charsets-500.woff2
new file mode 100644
index 000000000000..722245682f59
Binary files /dev/null and b/docs/book/book/fonts/source-code-pro-v11-all-charsets-500.woff2 differ
diff --git a/docs/book/book/highlight.css b/docs/book/book/highlight.css
new file mode 100644
index 000000000000..ba57b82b27de
--- /dev/null
+++ b/docs/book/book/highlight.css
@@ -0,0 +1,82 @@
+/*
+ * An increased contrast highlighting scheme loosely based on the
+ * "Base16 Atelier Dune Light" theme by Bram de Haan
+ * (http://atelierbram.github.io/syntax-highlighting/atelier-schemes/dune)
+ * Original Base16 color scheme by Chris Kempson
+ * (https://github.com/chriskempson/base16)
+ */
+
+/* Comment */
+.hljs-comment,
+.hljs-quote {
+ color: #575757;
+}
+
+/* Red */
+.hljs-variable,
+.hljs-template-variable,
+.hljs-attribute,
+.hljs-tag,
+.hljs-name,
+.hljs-regexp,
+.hljs-link,
+.hljs-name,
+.hljs-selector-id,
+.hljs-selector-class {
+ color: #d70025;
+}
+
+/* Orange */
+.hljs-number,
+.hljs-meta,
+.hljs-built_in,
+.hljs-builtin-name,
+.hljs-literal,
+.hljs-type,
+.hljs-params {
+ color: #b21e00;
+}
+
+/* Green */
+.hljs-string,
+.hljs-symbol,
+.hljs-bullet {
+ color: #008200;
+}
+
+/* Blue */
+.hljs-title,
+.hljs-section {
+ color: #0030f2;
+}
+
+/* Purple */
+.hljs-keyword,
+.hljs-selector-tag {
+ color: #9d00ec;
+}
+
+.hljs {
+ display: block;
+ overflow-x: auto;
+ background: #f6f7f6;
+ color: #000;
+}
+
+.hljs-emphasis {
+ font-style: italic;
+}
+
+.hljs-strong {
+ font-weight: bold;
+}
+
+.hljs-addition {
+ color: #22863a;
+ background-color: #f0fff4;
+}
+
+.hljs-deletion {
+ color: #b31d28;
+ background-color: #ffeef0;
+}
diff --git a/docs/book/book/highlight.js b/docs/book/book/highlight.js
new file mode 100644
index 000000000000..180385b7028f
--- /dev/null
+++ b/docs/book/book/highlight.js
@@ -0,0 +1,6 @@
+/*
+ Highlight.js 10.1.1 (93fd0d73)
+ License: BSD-3-Clause
+ Copyright (c) 2006-2020, Ivan Sagalaev
+*/
+var hljs=function(){"use strict";function e(n){Object.freeze(n);var t="function"==typeof n;return Object.getOwnPropertyNames(n).forEach((function(r){!Object.hasOwnProperty.call(n,r)||null===n[r]||"object"!=typeof n[r]&&"function"!=typeof n[r]||t&&("caller"===r||"callee"===r||"arguments"===r)||Object.isFrozen(n[r])||e(n[r])})),n}class n{constructor(e){void 0===e.data&&(e.data={}),this.data=e.data}ignoreMatch(){this.ignore=!0}}function t(e){return e.replace(/&/g,"&").replace(//g,">").replace(/"/g,""").replace(/'/g,"'")}function r(e,...n){var t={};for(const n in e)t[n]=e[n];return n.forEach((function(e){for(const n in e)t[n]=e[n]})),t}function a(e){return e.nodeName.toLowerCase()}var i=Object.freeze({__proto__:null,escapeHTML:t,inherit:r,nodeStream:function(e){var n=[];return function e(t,r){for(var i=t.firstChild;i;i=i.nextSibling)3===i.nodeType?r+=i.nodeValue.length:1===i.nodeType&&(n.push({event:"start",offset:r,node:i}),r=e(i,r),a(i).match(/br|hr|img|input/)||n.push({event:"stop",offset:r,node:i}));return r}(e,0),n},mergeStreams:function(e,n,r){var i=0,s="",o=[];function l(){return e.length&&n.length?e[0].offset!==n[0].offset?e[0].offset
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Features
+Annotations
+Source: annotations.rs
+Provides user with annotations above items for looking up references or impl blocks +and running/debugging binaries.
+
Auto Import
+Source: auto_import.rs
+Using the auto-import assist it is possible to insert missing imports for unresolved items.
+When inserting an import it will do so in a structured manner by keeping imports grouped,
+separated by a newline in the following order:
-
+
stdandcore
+- External Crates +
- Current Crate, paths prefixed by
crate
+ - Current Module, paths prefixed by
self
+ - Super Module, paths prefixed by
super
+
Example:
+use std::fs::File;
+
+use itertools::Itertools;
+use syntax::ast;
+
+use crate::utils::insert_use;
+
+use self::auto_import;
+
+use super::AssistContext;Import Granularity
+It is possible to configure how use-trees are merged with the imports.granularity.group setting.
+It has the following configurations:
-
+
crate: Merge imports from the same crate into a single use statement. This kind of +nesting is only supported in Rust versions later than 1.24.
+module: Merge imports from the same module into a single use statement.
+item: Don't merge imports at all, creating one import per item.
+preserve: Do not change the granularity of any imports. For auto-import this has the same +effect asitem.
+
In VS Code the configuration for this is rust-analyzer.imports.granularity.group.
Import Prefix
+The style of imports in the same crate is configurable through the imports.prefix setting.
+It has the following configurations:
-
+
crate: This setting will force paths to be always absolute, starting with thecrate+prefix, unless the item is defined outside of the current crate.
+self: This setting will force paths that are relative to the current module to always +start withself. This will result in paths that always start with eithercrate,self, +superor an extern crate identifier.
+plain: This setting does not impose any restrictions in imports.
+
In VS Code the configuration for this is rust-analyzer.imports.prefix.
Completion With Autoimport
+Source: flyimport.rs
+When completing names in the current scope, proposes additional imports from other modules or crates, +if they can be qualified in the scope, and their name contains all symbols from the completion input.
+To be considered applicable, the name must contain all input symbols in the given order, not necessarily adjacent. +If any input symbol is not lowercased, the name must contain all symbols in exact case; otherwise the containing is checked case-insensitively.
+fn main() {
+ pda$0
+}
+# pub mod std { pub mod marker { pub struct PhantomData { } } }
+->
+use std::marker::PhantomData;
+
+fn main() {
+ PhantomData
+}
+# pub mod std { pub mod marker { pub struct PhantomData { } } }
+Also completes associated items, that require trait imports. +If any unresolved and/or partially-qualified path precedes the input, it will be taken into account. +Currently, only the imports with their import path ending with the whole qualifier will be proposed +(no fuzzy matching for qualifier).
+mod foo {
+ pub mod bar {
+ pub struct Item;
+
+ impl Item {
+ pub const TEST_ASSOC: usize = 3;
+ }
+ }
+}
+
+fn main() {
+ bar::Item::TEST_A$0
+}
+->
+use foo::bar;
+
+mod foo {
+ pub mod bar {
+ pub struct Item;
+
+ impl Item {
+ pub const TEST_ASSOC: usize = 3;
+ }
+ }
+}
+
+fn main() {
+ bar::Item::TEST_ASSOC
+}
+NOTE: currently, if an assoc item comes from a trait that's not currently imported, and it also has an unresolved and/or partially-qualified path, +no imports will be proposed.
+Fuzzy search details
+To avoid an excessive amount of the results returned, completion input is checked for inclusion in the names only
+(i.e. in HashMap in the std::collections::HashMap path).
+For the same reasons, avoids searching for any path imports for inputs with their length less than 2 symbols
+(but shows all associated items for any input length).
Import configuration
+It is possible to configure how use-trees are merged with the imports.granularity.group setting.
+Mimics the corresponding behavior of the Auto Import feature.
LSP and performance implications
+The feature is enabled only if the LSP client supports LSP protocol version 3.16+ and reports the additionalTextEdits
+(case-sensitive) resolve client capability in its client capabilities.
+This way the server is able to defer the costly computations, doing them for a selected completion item only.
+For clients with no such support, all edits have to be calculated on the completion request, including the fuzzy search completion ones,
+which might be slow ergo the feature is automatically disabled.
Feature toggle
+The feature can be forcefully turned off in the settings with the rust-analyzer.completion.autoimport.enable flag.
+Note that having this flag set to true does not guarantee that the feature is enabled: your client needs to have the corresponding
+capability enabled.
Debug ItemTree
+Source: view_item_tree.rs
+Displays the ItemTree of the currently open file, for debugging.
+| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: Debug ItemTree |
Expand Macro Recursively
+Source: expand_macro.rs
+Shows the full macro expansion of the macro at current cursor.
+| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: Expand macro recursively |
Expand and Shrink Selection
+Source: extend_selection.rs
+Extends or shrinks the current selection to the encompassing syntactic construct +(expression, statement, item, module, etc). It works with multiple cursors.
+| Editor | Shortcut |
|---|---|
| VS Code | Alt+Shift+→, Alt+Shift+← |
File Structure
+Source: file_structure.rs
+Provides a tree of the symbols defined in the file. Can be used to
+-
+
- fuzzy search symbol in a file (super useful) +
- draw breadcrumbs to describe the context around the cursor +
- draw outline of the file +
| Editor | Shortcut |
|---|---|
| VS Code | Ctrl+Shift+O |
Find All References
+Source: references.rs
+Shows all references of the item at the cursor location
+| Editor | Shortcut |
|---|---|
| VS Code | Shift+Alt+F12 |
Folding
+Source: folding_ranges.rs
+Defines folding regions for curly braced blocks, runs of consecutive use, mod, const or static
+items, and region / endregion comment markers.
Format String Completion
+Source: format_like.rs
+"Result {result} is {2 + 2}" is expanded to the "Result {} is {}", result, 2 + 2.
The following postfix snippets are available:
+-
+
format->format!(...)
+panic->panic!(...)
+println->println!(...)
+log: +**logd->log::debug!(...)+**logt->log::trace!(...)+**logi->log::info!(...)+**logw->log::warn!(...)+**loge->log::error!(...)
+
Go to Declaration
+Source: goto_declaration.rs
+Navigates to the declaration of an identifier.
+This is the same as Go to Definition with the following exceptions:
-
+
- outline modules will navigate to the
mod name;item declaration
+ - trait assoc items will navigate to the assoc item of the trait declaration opposed to the trait impl +
- fields in patterns will navigate to the field declaration of the struct, union or variant +
Go to Definition
+Source: goto_definition.rs
+Navigates to the definition of an identifier.
+For outline modules, this will navigate to the source file of the module.
+| Editor | Shortcut |
|---|---|
| VS Code | F12 |
Go to Implementation
+Source: goto_implementation.rs
+Navigates to the impl blocks of types.
+| Editor | Shortcut |
|---|---|
| VS Code | Ctrl+F12 |
Go to Type Definition
+Source: goto_type_definition.rs
+Navigates to the type of an identifier.
+| Editor | Action Name |
|---|---|
| VS Code | Go to Type Definition |
Highlight Related
+Source: highlight_related.rs
+Highlights constructs related to the thing under the cursor:
+. if on an identifier, highlights all references to that identifier in the current file
+.. additionally, if the identifier is a trait in a where clause, type parameter trait bound or use item, highlights all references to that trait's assoc items in the corresponding scope
+. if on an async or await token, highlights all yield points for that async context . if on a returnorfnkeyword,?character or->return type arrow, highlights all exit points for that context . if on abreak, loop, whileorfortoken, highlights all break points for that loop or block context . if on amoveor|` token that belongs to a closure, highlights all captures of the closure.
Note: ?, | and -> do not currently trigger this behavior in the VSCode editor.
Hover
+Source: hover.rs
+Shows additional information, like the type of an expression or the documentation for a definition when "focusing" code. +Focusing is usually hovering with a mouse, but can also be triggered with a shortcut.
+
Inlay Hints
+Source: inlay_hints.rs
+rust-analyzer shows additional information inline with the source code. +Editors usually render this using read-only virtual text snippets interspersed with code.
+rust-analyzer by default shows hints for
+-
+
- types of local variables +
- names of function arguments +
- types of chained expressions +
Optionally, one can enable additional hints for
+-
+
- return types of closure expressions +
- elided lifetimes +
- compiler inserted reborrows +
Interpret Function
+Source: interpret_function.rs
+| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: Interpret Function |
Join Lines
+Source: join_lines.rs
+Join selected lines into one, smartly fixing up whitespace, trailing commas, and braces.
+See this gif for the cases handled specially by joined lines.
+
| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: Join lines |
Magic Completions
+Source: lib.rs
+In addition to usual reference completion, rust-analyzer provides some ✨magic✨ +completions as well:
+Keywords like if, else while, loop are completed with braces, and cursor
+is placed at the appropriate position. Even though if is easy to type, you
+still want to complete it, to get { } for free! return is inserted with a
+space or ; depending on the return type of the function.
When completing a function call, () are automatically inserted. If a function
+takes arguments, the cursor is positioned inside the parenthesis.
There are postfix completions, which can be triggered by typing something like
+foo().if. The word after . determines postfix completion. Possible variants are:
-
+
expr.if->if expr {}orif let ... {}forOptionorResult
+expr.match->match expr {}
+expr.while->while expr {}orwhile let ... {}forOptionorResult
+expr.ref->&expr
+expr.refm->&mut expr
+expr.let->let $0 = expr;
+expr.letm->let mut $0 = expr;
+expr.not->!expr
+expr.dbg->dbg!(expr)
+expr.dbgr->dbg!(&expr)
+expr.call->(expr)
+
There also snippet completions:
+Expressions
+-
+
pd->eprintln!(" = {:?}", );
+ppd->eprintln!(" = {:#?}", );
+
Items
+-
+
tfn->#[test] fn feature(){}
+tmod->
+
#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_name() {}
+}And the auto import completions, enabled with the rust-analyzer.completion.autoimport.enable setting and the corresponding LSP client capabilities.
+Those are the additional completion options with automatic use import and options from all project importable items,
+fuzzy matched against the completion input.
Matching Brace
+Source: matching_brace.rs
+If the cursor is on any brace (<>(){}[]||) which is a part of a brace-pair,
+moves cursor to the matching brace. It uses the actual parser to determine
+braces, so it won't confuse generics with comparisons.
| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: Find matching brace |
Memory Usage
+Source: apply_change.rs
+Clears rust-analyzer's internal database and prints memory usage statistics.
+| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: Memory Usage (Clears Database) |
Move Item
+Source: move_item.rs
+Move item under cursor or selection up and down.
+| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: Move item up |
| VS Code | rust-analyzer: Move item down |
On Enter
+Source: on_enter.rs
+rust-analyzer can override kbd:[Enter] key to make it smarter:
+-
+
- Enter inside triple-slash comments automatically inserts
///
+ - Enter in the middle or after a trailing space in
//inserts//
+ - Enter inside
//!doc comments automatically inserts//!
+ - Enter after
{indents contents and closing}of single-line block
+
This action needs to be assigned to shortcut explicitly.
+Note that, depending on the other installed extensions, this feature can visibly slow down typing.
+Similarly, if rust-analyzer crashes or stops responding, Enter might not work.
+In that case, you can still press Shift-Enter to insert a newline.
VS Code::
+Add the following to keybindings.json:
{
+ "key": "Enter",
+ "command": "rust-analyzer.onEnter",
+ "when": "editorTextFocus && !suggestWidgetVisible && editorLangId == rust"
+}
+When using the Vim plugin:
+{
+ "key": "Enter",
+ "command": "rust-analyzer.onEnter",
+ "when": "editorTextFocus && !suggestWidgetVisible && editorLangId == rust && vim.mode == 'Insert'"
+}
+
On Typing Assists
+Source: typing.rs
+Some features trigger on typing certain characters:
+-
+
- typing
let =tries to smartly add;if=is followed by an existing expression
+ - typing
=between two expressions adds;when in statement position
+ - typing
=to turn an assignment into an equality comparison removes;when in expression position
+ - typing
.in a chain method call auto-indents
+ - typing
{or(in front of an expression inserts a closing}or)after the expression
+ - typing
{in a use item adds a closing}in the right place
+
VS Code::
+Add the following to settings.json:
"editor.formatOnType": true,
+
+
Open Docs
+Source: doc_links.rs
+Retrieve a links to documentation for the given symbol.
+The simplest way to use this feature is via the context menu. Right-click on +the selected item. The context menu opens. Select Open Docs.
+| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: Open Docs |
Parent Module
+Source: parent_module.rs
+Navigates to the parent module of the current module.
+| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: Locate parent module |
Related Tests
+Source: runnables.rs
+Provides a sneak peek of all tests where the current item is used.
+The simplest way to use this feature is via the context menu. Right-click on +the selected item. The context menu opens. Select Peek Related Tests.
+| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: Peek Related Tests |
Rename
+Source: rename.rs
+Renames the item below the cursor and all of its references
+| Editor | Shortcut |
|---|---|
| VS Code | F2 |
Run
+Source: runnables.rs
+Shows a popup suggesting to run a test/benchmark/binary at the current cursor +location. Super useful for repeatedly running just a single test. Do bind this +to a shortcut!
+| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: Run |
Semantic Syntax Highlighting
+Source: syntax_highlighting.rs
+rust-analyzer highlights the code semantically.
+For example, Bar in foo::Bar might be colored differently depending on whether Bar is an enum or a trait.
+rust-analyzer does not specify colors directly, instead it assigns a tag (like struct) and a set of modifiers (like declaration) to each token.
+It's up to the client to map those to specific colors.
The general rule is that a reference to an entity gets colored the same way as the entity itself.
+We also give special modifier for mut and &mut local variables.
Token Tags
+Rust-analyzer currently emits the following token tags:
+-
+
- For items: +
| attribute | Emitted for attribute macros. |
| enum | Emitted for enums. |
| function | Emitted for free-standing functions. |
| derive | Emitted for derive macros. |
| macro | Emitted for function-like macros. |
| method | Emitted for associated functions, also knowns as methods. |
| namespace | Emitted for modules. |
| struct | Emitted for structs. |
| trait | Emitted for traits. |
| typeAlias | Emitted for type aliases and Self in impls. |
| union | Emitted for unions. |
-
+
- For literals: +
| boolean | Emitted for the boolean literals true and false. |
| character | Emitted for character literals. |
| number | Emitted for numeric literals. |
| string | Emitted for string literals. |
| escapeSequence | Emitted for escaped sequences inside strings like \n. |
| formatSpecifier | Emitted for format specifiers {:?} in format!-like macros. |
-
+
- For operators: +
| operator | Emitted for general operators. |
| arithmetic | Emitted for the arithmetic operators +, -, *, /, +=, -=, *=, /=. |
| bitwise | Emitted for the bitwise operators ` |
| comparison | Emitted for the comparison oerators >, <, ==, >=, <=, !=. |
| logical | Emitted for the logical operatos ` |
-
+
- For punctuation: +
| punctuation | Emitted for general punctuation. |
| attributeBracket | Emitted for attribute invocation brackets, that is the #[ and ] tokens. |
| angle | Emitted for <> angle brackets. |
| brace | Emitted for {} braces. |
| bracket | Emitted for [] brackets. |
| parenthesis | Emitted for () parentheses. |
| colon | Emitted for the : token. |
| comma | Emitted for the , token. |
| dot | Emitted for the . token. |
| semi | Emitted for the ; token. |
| macroBang | Emitted for the ! token in macro calls. |
-
+
+
| builtinAttribute | Emitted for names to builtin attributes in attribute path, the repr in #[repr(u8)] for example. |
| builtinType | Emitted for builtin types like u32, str and f32. |
| comment | Emitted for comments. |
| constParameter | Emitted for const parameters. |
| deriveHelper | Emitted for derive helper attributes. |
| enumMember | Emitted for enum variants. |
| generic | Emitted for generic tokens that have no mapping. |
| keyword | Emitted for keywords. |
| label | Emitted for labels. |
| lifetime | Emitted for lifetimes. |
| parameter | Emitted for non-self function parameters. |
| property | Emitted for struct and union fields. |
| selfKeyword | Emitted for the self function parameter and self path-specifier. |
| selfTypeKeyword | Emitted for the Self type parameter. |
| toolModule | Emitted for tool modules. |
| typeParameter | Emitted for type parameters. |
| unresolvedReference | Emitted for unresolved references, names that rust-analyzer can't find the definition of. |
| variable | Emitted for locals, constants and statics. |
Token Modifiers
+Token modifiers allow to style some elements in the source code more precisely.
+Rust-analyzer currently emits the following token modifiers:
+| async | Emitted for async functions and the async and await keywords. |
| attribute | Emitted for tokens inside attributes. |
| callable | Emitted for locals whose types implements one of the Fn* taits. |
| constant | Emitted for const. |
| consuming | Emitted for locals that are being consumed when use in a fuction call. |
| controlFlow | Emitted for control-flow related tokens, this includes th ? operator. |
| crateRoot | Emitted for crate names, like serde and `crate. |
| declaration | Emitted for names of definitions, like foo in fn foo(){}. |
| defaultLibrary | Emitted for items from built-in crates (std, core, allc, test and proc_macro). |
| documentation | Emitted for documentation comment. |
| injected | Emitted for doc-string injected highlighting like rust sourc blocks in documentation. |
| intraDocLink | Emitted for intra doc links in doc-string. |
| library | Emitted for items that are defined outside of the current crae. |
| macro | Emitted for tokens inside macro call. |
| mutable | Emitted for mutable locals and statics as well as functions tking &mut self. |
| public | Emitted for items that are from the current crate and are `pub. |
| reference | Emitted for locals behind a reference and functions taking self` by reference. |
| static | Emitted for "static" functions, also known as functions that d not take a self param, as well as statics and consts. |
| trait | Emitted for associated trait item. |
| unsafe | Emitted for unsafe operations, like unsafe function calls, as ell as the unsafe token. |
+
Show Dependency Tree
+Source: fetch_crates.rs
+Shows a view tree with all the dependencies of this project
+| Editor | Panel Name |
|---|---|
| VS Code | Rust Dependencies |
Show Syntax Tree
+Source: syntax_tree.rs
+Shows the parse tree of the current file. It exists mostly for debugging +rust-analyzer itself.
+| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: Show Syntax Tree |
Shuffle Crate Graph
+Source: shuffle_crate_graph.rs
+Randomizes all crate IDs in the crate graph, for debugging.
+| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: Shuffle Crate Graph |
Status
+Source: status.rs
+Shows internal statistic about memory usage of rust-analyzer.
+| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: Status |
Structural Search and Replace
+Source: lib.rs
+Search and replace with named wildcards that will match any expression, type, path, pattern or item.
+The syntax for a structural search replace command is <search_pattern> ==>> <replace_pattern>.
+A $<name> placeholder in the search pattern will match any AST node and $<name> will reference it in the replacement.
+Within a macro call, a placeholder will match up until whatever token follows the placeholder.
All paths in both the search pattern and the replacement template must resolve in the context
+in which this command is invoked. Paths in the search pattern will then match the code if they
+resolve to the same item, even if they're written differently. For example if we invoke the
+command in the module foo with a pattern of Bar, then code in the parent module that refers
+to foo::Bar will match.
Paths in the replacement template will be rendered appropriately for the context in which the
+replacement occurs. For example if our replacement template is foo::Bar and we match some
+code in the foo module, we'll insert just Bar.
Inherent method calls should generally be written in UFCS form. e.g. foo::Bar::baz($s, $a) will
+match $s.baz($a), provided the method call baz resolves to the method foo::Bar::baz. When a
+placeholder is the receiver of a method call in the search pattern (e.g. $s.foo()), but not in
+the replacement template (e.g. bar($s)), then *, & and &mut will be added as needed to mirror
+whatever autoderef and autoref was happening implicitly in the matched code.
The scope of the search / replace will be restricted to the current selection if any, otherwise +it will apply to the whole workspace.
+Placeholders may be given constraints by writing them as ${<name>:<constraint1>:<constraint2>...}.
Supported constraints:
+| Constraint | Restricts placeholder |
|---|---|
| kind(literal) | Is a literal (e.g. 42 or "forty two") |
| not(a) | Negates the constraint a |
Available via the command rust-analyzer.ssr.
// Using structural search replace command [foo($a, $b) ==>> ($a).foo($b)]
+
+// BEFORE
+String::from(foo(y + 5, z))
+
+// AFTER
+String::from((y + 5).foo(z))| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: Structural Search Replace |
Also available as an assist, by writing a comment containing the structural +search and replace rule. You will only see the assist if the comment can +be parsed as a valid structural search and replace rule.
+// Place the cursor on the line below to see the assist 💡.
+// foo($a, $b) ==>> ($a).foo($b)User Snippet Completions
+Source: snippet.rs
+rust-analyzer allows the user to define custom (postfix)-snippets that may depend on items to be accessible for the current scope to be applicable.
+A custom snippet can be defined by adding it to the rust-analyzer.completion.snippets.custom object respectively.
{
+ "rust-analyzer.completion.snippets.custom": {
+ "thread spawn": {
+ "prefix": ["spawn", "tspawn"],
+ "body": [
+ "thread::spawn(move || {",
+ "\t$0",
+ "});",
+ ],
+ "description": "Insert a thread::spawn call",
+ "requires": "std::thread",
+ "scope": "expr",
+ }
+ }
+}
+In the example above:
+-
+
-
+
+"thread spawn"is the name of the snippet.
+ -
+
+prefixdefines one or more trigger words that will trigger the snippets completion. +Usingpostfixwill instead create a postfix snippet.
+ -
+
+bodyis one or more lines of content joined via newlines for the final output.
+ -
+
+descriptionis an optional description of the snippet, if unset the snippet name will be used.
+ -
+
+requiresis an optional list of item paths that have to be resolvable in the current crate where the completion is rendered.
+
View Crate Graph
+Source: view_crate_graph.rs
+Renders the currently loaded crate graph as an SVG graphic. Requires the dot tool, which
+is part of graphviz, to be installed.
Only workspace crates are included, no crates.io dependencies or sysroot crates.
+| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: View Crate Graph |
View Hir
+Source: view_hir.rs
+| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: View Hir |
View Memory Layout
+Source: view_memory_layout.rs
+Displays the recursive memory layout of a datatype.
+| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: View Memory Layout |
View Mir
+Source: view_mir.rs
+| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: View Mir |
Workspace Symbol
+Source: symbol_index.rs
+Uses fuzzy-search to find types, modules and functions by name across your
+project and dependencies. This is the most useful feature, which improves code
+navigation tremendously. It mostly works on top of the built-in LSP
+functionality, however # and * symbols can be used to narrow down the
+search. Specifically,
-
+
Foosearches forFootype in the current workspace
+foo#searches forfoofunction in the current workspace
+Foo*searches forFootype among dependencies, includingstdlib
+foo#*searches forfoofunction among dependencies
+
That is, # switches from "types" to all symbols, * switches from the current
+workspace to dependencies.
Note that filtering does not currently work in VSCode due to the editor never
+sending the special symbols to the language server. Instead, you can configure
+the filtering via the rust-analyzer.workspace.symbol.search.scope and
+rust-analyzer.workspace.symbol.search.kind settings.
| Editor | Shortcut |
|---|---|
| VS Code | Ctrl+T |
":e:f.tabReplace?e.replace(/\t/g,f.tabReplace):e):e}function E(e){let n=null;const t=function(e){var n=e.className+" ";n+=e.parentNode?e.parentNode.className:"";const t=f.languageDetectRe.exec(n);if(t){var r=T(t[1]);return r||(console.warn(g.replace("{}",t[1])),console.warn("Falling back to no-highlight mode for this block.",e)),r?t[1]:"no-highlight"}return n.split(/\s+/).find(e=>p(e)||T(e))}(e);if(p(t))return;S("before:highlightBlock",{block:e,language:t}),f.useBR?(n=document.createElement("div")).innerHTML=e.innerHTML.replace(/\n/g,"").replace(/
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/book/book/installation/index.html b/docs/book/book/installation/index.html
new file mode 100644
index 000000000000..60d393035ac0
--- /dev/null
+++ b/docs/book/book/installation/index.html
@@ -0,0 +1,768 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ rust-analyzer
+At its core, rust-analyzer is a library for semantic analysis of +Rust code as it changes over time. This manual focuses on a specific +usage of the library — running it as part of a server that implements +the Language Server +Protocol (LSP). +The LSP allows various code editors, like VS Code, Emacs or Vim, to +implement semantic features like completion or goto definition by +talking to an external language server process.
+To improve this document, send a pull request:
+https://github.com/rust-analyzer/…/manual.adoc
The manual is written in AsciiDoc and includes
+some extra files which are generated from the source code. Run
+cargo test and cargo test -p xtask to create these and then
+asciidoctor manual.adoc to create an HTML copy.
If you have questions about using rust-analyzer, please ask them in the +“IDEs and Editors” topic of Rust +users forum.
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/book/book/mark.min.js b/docs/book/book/mark.min.js
new file mode 100644
index 000000000000..163623188347
--- /dev/null
+++ b/docs/book/book/mark.min.js
@@ -0,0 +1,7 @@
+/*!***************************************************
+* mark.js v8.11.1
+* https://markjs.io/
+* Copyright (c) 2014–2018, Julian Kühnel
+* Released under the MIT license https://git.io/vwTVl
+*****************************************************/
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):e.Mark=t()}(this,function(){"use strict";var e="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},t=function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")},n=function(){function e(e,t){for(var n=0;n
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Installation
+In theory, one should be able to just install the rust-analyzer
+binary and have it automatically
+work with any editor. We are not there yet, so some editor specific
+setup is required.
Additionally, rust-analyzer needs the sources of the standard library. +If the source code is not present, rust-analyzer will attempt to install +it automatically.
+To add the sources manually, run the following command:
+$ rustup component add rust-src
+Toolchain
+Only the latest stable standard library source is officially supported +for use with rust-analyzer. If you are using an older toolchain or have +an override set, rust-analyzer may fail to understand the Rust source. +You will either need to update your toolchain or use an older version of +rust-analyzer that is compatible with your toolchain.
+If you are using an override in your project, you can still force
+rust-analyzer to use the stable toolchain via the environment variable
+RUSTUP_TOOLCHAIN. For example, with VS Code or coc-rust-analyzer:
{ "rust-analyzer.server.extraEnv": { "RUSTUP_TOOLCHAIN": "stable" } }
+VS Code
+This is the best supported editor at the moment. The rust-analyzer +plugin for VS Code is maintained in +tree.
+You can install the latest release of the plugin from the +marketplace.
+Note that the plugin may cause conflicts with the previous official +Rust +plugin. +The latter is no longer maintained and should be uninstalled.
+The server binary is stored in the extension install directory, which
+starts with rust-lang.rust-analyzer- and is located under:
-
+
-
+
Linux:
+~/.vscode/extensions
+ -
+
Linux (Remote, such as WSL):
+~/.vscode-server/extensions
+ -
+
macOS:
+~/.vscode/extensions
+ -
+
Windows:
+%USERPROFILE%\.vscode\extensions
+
As an exception, on NixOS, the extension makes a copy of the server and
+stores it under
+~/.config/Code/User/globalStorage/rust-lang.rust-analyzer.
Note that we only support the two most recent versions of VS Code.
+Updates
+The extension will be updated automatically as new versions become +available. It will ask your permission to download the matching language +server version binary if needed.
+Nightly
+We ship nightly releases for VS Code. To help us out by testing the +newest code, you can enable pre-release versions in the Code extension +page.
+Manual installation
+Alternatively, download a VSIX corresponding to your platform from the +releases page.
+Install the extension with the Extensions: Install from VSIX command
+within VS Code, or from the command line via:
$ code --install-extension /path/to/rust-analyzer.vsix
+If you are running an unsupported platform, you can install
+rust-analyzer-no-server.vsix and compile or obtain a server binary.
+Copy the server anywhere, then add the path to your settings.json, for
+example:
{ "rust-analyzer.server.path": "~/.local/bin/rust-analyzer-linux" }
+Building From Source
+Both the server and the Code plugin can be installed from source:
+$ git clone https://github.com/rust-lang/rust-analyzer.git && cd rust-analyzer
+$ cargo xtask install
+You’ll need Cargo, nodejs (matching a supported version of VS Code) and +npm for this.
+Note that installing via xtask install does not work for VS Code
+Remote, instead you’ll need to install the .vsix manually.
If you’re not using Code, you can compile and install only the LSP +server:
+$ cargo xtask install --server
+Make sure that .cargo/bin is in $PATH and precedes paths where
+rust-analyzer may also be installed. Specifically, rustup includes a
+proxy called rust-analyzer, which can cause problems if you’re
+planning to use a source build or even a downloaded binary.
rust-analyzer Language Server Binary
+Other editors generally require the rust-analyzer binary to be in
+$PATH. You can download pre-built binaries from the
+releases page.
+You will need to uncompress and rename the binary for your platform,
+e.g. from rust-analyzer-aarch64-apple-darwin.gz on Mac OS to
+rust-analyzer, make it executable, then move it into a directory in
+your $PATH.
On Linux to install the rust-analyzer binary into ~/.local/bin,
+these commands should work:
$ mkdir -p ~/.local/bin
+$ curl -L https://github.com/rust-lang/rust-analyzer/releases/latest/download/rust-analyzer-x86_64-unknown-linux-gnu.gz | gunzip -c - > ~/.local/bin/rust-analyzer
+$ chmod +x ~/.local/bin/rust-analyzer
+Make sure that ~/.local/bin is listed in the $PATH variable and use
+the appropriate URL if you’re not on a x86-64 system.
You don’t have to use ~/.local/bin, any other path like ~/.cargo/bin
+or /usr/local/bin will work just as well.
Alternatively, you can install it from source using the command below. +You’ll need the latest stable version of the Rust toolchain.
+$ git clone https://github.com/rust-lang/rust-analyzer.git && cd rust-analyzer
+$ cargo xtask install --server
+If your editor can’t find the binary even though the binary is on your
+$PATH, the likely explanation is that it doesn’t see the same $PATH
+as the shell, see this
+issue. On Unix,
+running the editor from a shell or changing the .desktop file to set
+the environment should help.
rustup
+rust-analyzer is available in rustup:
$ rustup component add rust-analyzer
+Arch Linux
+The rust-analyzer binary can be installed from the repos or AUR (Arch
+User Repository):
-
+
-
+
+rust-analyzer+(built from latest tagged source)
+ -
+
+rust-analyzer-git+(latest Git version)
+
Install it with pacman, for example:
+$ pacman -S rust-analyzer
+Gentoo Linux
+rust-analyzer is available in the GURU repository:
-
+
-
+
+dev-util/rust-analyzer+builds from source
+ -
+
+dev-util/rust-analyzer-bin+installs an official binary release
+
If not already, GURU must be enabled (e.g. using
+app-eselect/eselect-repository) and sync’d before running emerge:
$ eselect repository enable guru && emaint sync -r guru
+$ emerge rust-analyzer-bin
+macOS
+The rust-analyzer binary can be installed via
+Homebrew.
$ brew install rust-analyzer
+VS Code or VSCodium in Flatpak
+Setting up rust-analyzer with a Flatpak version of Code is not trivial
+because of the Flatpak sandbox. While the sandbox can be disabled for
+some directories, /usr/bin will always be mounted under
+/run/host/usr/bin. This prevents access to the system’s C compiler, a
+system-wide installation of Rust, or any other libraries you might want
+to link to. Some compilers and libraries can be acquired as Flatpak
+SDKs, such as org.freedesktop.Sdk.Extension.rust-stable or
+org.freedesktop.Sdk.Extension.llvm15.
If you use a Flatpak SDK for Rust, there should be no extra steps +necessary.
+If you want to use Flatpak in combination with rustup, the following
+steps might help:
-
+
-
+
both Rust and
+rustuphave to be installed using +https://rustup.rs. Distro packages will not work.
+ -
+
you need to launch Code, open a terminal and run
+echo $PATH
+ -
+
using +Flatseal, +you must add an environment variable called
+PATH. Set its value to +the output from above, appending:~/.cargo/bin, where~is the +path to your home directory. You must replace~, as it won’t be +expanded otherwise.
+ -
+
while Flatseal is open, you must enable access to "All user files"
+
+
A C compiler should already be available via org.freedesktop.Sdk. Any
+other tools or libraries you will need to acquire from Flatpak.
Emacs
+Prerequisites: You have installed the rust-analyzer
+binary.
To use rust-analyzer, you need to install and enable one of the two
+popular LSP client implementations for Emacs,
+Eglot or LSP
+Mode. Both enable
+rust-analyzer by default in rust buffers if it is available.
Eglot
+Eglot is the more minimalistic and lightweight LSP client for Emacs, +integrates well with existing Emacs functionality and is built into +Emacs starting from release 29.
+After installing Eglot, e.g. via M-x package-install (not needed from
+Emacs 29), you can enable it via the M-x eglot command or load it
+automatically in rust-mode via
(add-hook 'rust-mode-hook 'eglot-ensure)
+To enable clippy, you will need to configure the initialization options
+to pass the check.command setting.
(add-to-list 'eglot-server-programs
+ '((rust-ts-mode rust-mode) .
+ ("rust-analyzer" :initializationOptions (:check (:command "clippy")))))
+For more detailed instructions and options see the Eglot
+manual (also available from Emacs
+via M-x info) and the Eglot
+readme.
Eglot does not support the rust-analyzer extensions to the +language-server protocol and does not aim to do so in the future. The +eglot-x +package adds experimental support for those LSP extensions.
+LSP Mode
+LSP-mode is the original LSP-client for emacs. Compared to Eglot it has +a larger codebase and supports more features, like LSP protocol +extensions. With extension packages like LSP +UI it offers a lot of visual +eyecandy. Further it integrates well with DAP +mode for support of the Debug +Adapter Protocol.
+You can install LSP-mode via M-x package-install and then run it via
+the M-x lsp command or load it automatically in rust buffers with
(add-hook 'rust-mode-hook 'lsp-deferred)
+For more information on how to set up LSP mode and its extension package
+see the instructions in the LSP mode
+manual. Also
+see the rust-analyzer
+section
+for rust-analyzer specific options and commands, which you can
+optionally bind to keys.
Note the excellent +guide from +@rksm on how to set-up Emacs for Rust +development with LSP mode and several other packages.
+Vim/Neovim
+Prerequisites: You have installed the rust-analyzer
+binary. Not needed if the
+extension can install/update it on its own, coc-rust-analyzer is one
+example.
There are several LSP client implementations for Vim or Neovim:
+coc-rust-analyzer
+-
+
-
+
Install coc.nvim by following the instructions at +coc.nvim (Node.js required)
+
+ -
+
Run
+:CocInstall coc-rust-analyzerto install +coc-rust-analyzer, +this extension implements most of the features supported in the +VSCode extension:-
+
-
+
automatically install and upgrade stable/nightly releases
+
+ -
+
same configurations as VSCode extension, +
+rust-analyzer.server.path,rust-analyzer.cargo.featuresetc.
+ -
+
same commands too,
+rust-analyzer.analyzerStatus, +rust-analyzer.ssretc.
+ -
+
inlay hints for variables and method chaining, Neovim Only
+
+
+ -
+
Note: for code actions, use coc-codeaction-cursor and
+coc-codeaction-selected; coc-codeaction and coc-codeaction-line
+are unlikely to be useful.
LanguageClient-neovim
+-
+
-
+
Install LanguageClient-neovim by following the instructions +here
+-
+
- The GitHub project wiki has extra tips on configuration +
+ -
+
Configure by adding this to your Vim/Neovim config file (replacing +the existing Rust-specific line if it exists):
+
+let g:LanguageClient_serverCommands = { +\ 'rust': ['rust-analyzer'], +\ } +
+
YouCompleteMe
+Install YouCompleteMe by following the instructions +here.
+rust-analyzer is the default in ycm, it should work out of the box.
+ALE
+To use the LSP server in ale:
+let g:ale_linters = {'rust': ['analyzer']}
+nvim-lsp
+Neovim 0.5 has built-in language server support. For a quick start
+configuration of rust-analyzer, use
+neovim/nvim-lspconfig.
+Once neovim/nvim-lspconfig is installed, use
+lua require'lspconfig'.rust_analyzer.setup({}) in your init.vim.
You can also pass LSP settings to the server:
+lua << EOF
+local nvim_lsp = require'lspconfig'
+
+local on_attach = function(client)
+ require'completion'.on_attach(client)
+end
+
+nvim_lsp.rust_analyzer.setup({
+ on_attach=on_attach,
+ settings = {
+ ["rust-analyzer"] = {
+ imports = {
+ granularity = {
+ group = "module",
+ },
+ prefix = "self",
+ },
+ cargo = {
+ buildScripts = {
+ enable = true,
+ },
+ },
+ procMacro = {
+ enable = true
+ },
+ }
+ }
+})
+EOF
+See https://sharksforarms.dev/posts/neovim-rust/ for more tips on +getting started.
+Check out https://github.com/simrat39/rust-tools.nvim for a batteries +included rust-analyzer setup for Neovim.
+vim-lsp
+vim-lsp is installed by following the plugin
+instructions. It can be as
+simple as adding this line to your .vimrc:
Plug 'prabirshrestha/vim-lsp'
+Next you need to register the rust-analyzer binary. If it is available
+in $PATH, you may want to add this to your .vimrc:
if executable('rust-analyzer')
+ au User lsp_setup call lsp#register_server({
+ \ 'name': 'Rust Language Server',
+ \ 'cmd': {server_info->['rust-analyzer']},
+ \ 'whitelist': ['rust'],
+ \ })
+endif
+There is no dedicated UI for the server configuration, so you would need
+to send any options as a value of the initialization_options field, as
+described in the Configuration section. Here is an
+example of how to enable the proc-macro support:
if executable('rust-analyzer')
+ au User lsp_setup call lsp#register_server({
+ \ 'name': 'Rust Language Server',
+ \ 'cmd': {server_info->['rust-analyzer']},
+ \ 'whitelist': ['rust'],
+ \ 'initialization_options': {
+ \ 'cargo': {
+ \ 'buildScripts': {
+ \ 'enable': v:true,
+ \ },
+ \ },
+ \ 'procMacro': {
+ \ 'enable': v:true,
+ \ },
+ \ },
+ \ })
+endif
+Sublime Text
+Sublime Text 4:
+-
+
- Follow the instructions in +LSP-rust-analyzer. +
Install
+LSP-file-watcher-chokidar
+to enable file watching (workspace/didChangeWatchedFiles).
Sublime Text 3:
+-
+
-
+
Install the
+rust-analyzer+binary.
+ -
+
Install the LSP package.
+
+ -
+
From the command palette, run
+LSP: Enable Language Server Globally+and selectrust-analyzer.
+
If it worked, you should see "rust-analyzer, Line X, Column Y" on the +left side of the status bar, and after waiting a bit, functionalities +like tooltips on hovering over variables should become available.
+If you get an error saying No such file or directory: 'rust-analyzer',
+see the rust-analyzer binary
+section on installing the language server binary.
GNOME Builder
+GNOME Builder 3.37.1 and newer has native rust-analyzer support. If
+the LSP binary is not available, GNOME Builder can install it when
+opening a Rust file.
Eclipse IDE
+Support for Rust development in the Eclipse IDE is provided by Eclipse
+Corrosion. If available in PATH
+or in some standard location, rust-analyzer is detected and powers
+editing of Rust files without further configuration. If rust-analyzer
+is not detected, Corrosion will prompt you for configuration of your
+Rust toolchain and language server with a link to the Window >
+Preferences > Rust preference page; from here a button allows to
+download and configure rust-analyzer, but you can also reference
+another installation. You’ll need to close and reopen all .rs and Cargo
+files, or to restart the IDE, for this change to take effect.
Kate Text Editor
+Support for the language server protocol is built into Kate through the +LSP plugin, which is included by default. It is preconfigured to use +rust-analyzer for Rust sources since Kate 21.12.
+To change rust-analyzer config options, start from the following example +and put it into Kate’s "User Server Settings" tab (located under the LSP +Client settings):
+{
+ "servers": {
+ "rust": {
+ "initializationOptions": {
+ "cachePriming": {
+ "enable": false
+ },
+ "check": {
+ "allTargets": false
+ },
+ "checkOnSave": false
+ }
+ }
+ }
+}
+Then click on apply, and restart the LSP server for your rust project.
+juCi++
+juCi++ has built-in support for the +language server protocol, and since version 1.7.0 offers installation of +both Rust and rust-analyzer when opening a Rust file.
+Kakoune
+Kakoune supports LSP with the help of
+kak-lsp. Follow the
+instructions to
+install kak-lsp. To configure kak-lsp, refer to the configuration
+section which
+is basically about copying the configuration
+file in
+the right place (latest versions should use rust-analyzer by default).
Finally, you need to configure Kakoune to talk to kak-lsp (see Usage
+section). A basic
+configuration will only get you LSP but you can also activate inlay
+diagnostics and auto-formatting on save. The following might help you
+get all of this.
eval %sh{kak-lsp --kakoune -s $kak_session} # Not needed if you load it with plug.kak.
+hook global WinSetOption filetype=rust %{
+ # Enable LSP
+ lsp-enable-window
+
+ # Auto-formatting on save
+ hook window BufWritePre .* lsp-formatting-sync
+
+ # Configure inlay hints (only on save)
+ hook window -group rust-inlay-hints BufWritePost .* rust-analyzer-inlay-hints
+ hook -once -always window WinSetOption filetype=.* %{
+ remove-hooks window rust-inlay-hints
+ }
+}
+Helix
+Helix supports LSP by default.
+However, it won’t install rust-analyzer automatically. You can follow
+instructions for installing rust-analyzer
+binary.
Visual Studio 2022
+There are multiple rust-analyzer extensions for Visual Studio 2022 on +Windows:
+rust-analyzer.vs
+(License: Creative Commons Attribution-NonCommercial-ShareAlike 4.0 +International)
+ + +Support for Rust development in the Visual Studio IDE is enabled by the +rust-analyzer +package. Either click on the download link or install from IDE’s +extension manager. For now Visual Studio +2022 is required. All +editions are supported viz. Community, Professional & Enterprise. The +package aims to provide 0-friction installation and therefore comes +loaded with most things required including rust-analyzer binary. If +anything it needs is missing, appropriate errors / warnings will guide +the user. E.g. cargo.exe needs to be in path and the package will tell +you as much. This package is under rapid active development. So if you +encounter any issues please file it at +rust-analyzer.vs.
+VS_RustAnalyzer
+(License: GPL)
+ + +SourceGear Rust
+(License: closed source)
+ +GitHub (docs, issues, +discussions)
+-
+
-
+
Free (no-cost)
+
+ -
+
Supports all editions of Visual Studio 2022 on Windows: Community, +Professional, or Enterprise
+
+
Lapce
+Lapce has a Rust plugin which you can install
+directly. Unfortunately, it downloads an old version of rust-analyzer,
+but you can set the server path under Settings.
Crates
+There is a package named ra_ap_rust_analyzer available on
+crates.io, for someone
+who wants to use it programmatically.
For more details, see the publish +workflow.
+Zed
+Zed has native rust-analyzer support. If the LSP
+binary is not available, Zed can install it when opening a Rust file.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/book/book/print.html b/docs/book/book/print.html
new file mode 100644
index 000000000000..19d6809e590a
--- /dev/null
+++ b/docs/book/book/print.html
@@ -0,0 +1,4711 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Non-Cargo Based Projects
+rust-analyzer does not require Cargo. However, if you use some other
+build system, you’ll have to describe the structure of your project for
+rust-analyzer in the rust-project.json format:
interface JsonProject {
+ /// Path to the sysroot directory.
+ ///
+ /// The sysroot is where rustc looks for the
+ /// crates that are built-in to rust, such as
+ /// std.
+ ///
+ /// https://doc.rust-lang.org/rustc/command-line-arguments.html#--sysroot-override-the-system-root
+ ///
+ /// To see the current value of sysroot, you
+ /// can query rustc:
+ ///
+ /// ```
+ /// $ rustc --print sysroot
+ /// /Users/yourname/.rustup/toolchains/stable-x86_64-apple-darwin
+ /// ```
+ sysroot?: string;
+ /// Path to the directory with *source code* of
+ /// sysroot crates.
+ ///
+ /// By default, this is `lib/rustlib/src/rust/library`
+ /// relative to the sysroot.
+ ///
+ /// It should point to the directory where std,
+ /// core, and friends can be found:
+ ///
+ /// https://github.com/rust-lang/rust/tree/master/library.
+ ///
+ /// If provided, rust-analyzer automatically adds
+ /// dependencies on sysroot crates. Conversely,
+ /// if you omit this path, you can specify sysroot
+ /// dependencies yourself and, for example, have
+ /// several different "sysroots" in one graph of
+ /// crates.
+ sysroot_src?: string;
+ /// The set of crates comprising the current
+ /// project. Must include all transitive
+ /// dependencies as well as sysroot crate (libstd,
+ /// libcore and such).
+ crates: Crate[];
+}
+
+interface Crate {
+ /// Optional crate name used for display purposes,
+ /// without affecting semantics. See the `deps`
+ /// key for semantically-significant crate names.
+ display_name?: string;
+ /// Path to the root module of the crate.
+ root_module: string;
+ /// Edition of the crate.
+ edition: "2015" | "2018" | "2021";
+ /// Dependencies
+ deps: Dep[];
+ /// Should this crate be treated as a member of
+ /// current "workspace".
+ ///
+ /// By default, inferred from the `root_module`
+ /// (members are the crates which reside inside
+ /// the directory opened in the editor).
+ ///
+ /// Set this to `false` for things like standard
+ /// library and 3rd party crates to enable
+ /// performance optimizations (rust-analyzer
+ /// assumes that non-member crates don't change).
+ is_workspace_member?: boolean;
+ /// Optionally specify the (super)set of `.rs`
+ /// files comprising this crate.
+ ///
+ /// By default, rust-analyzer assumes that only
+ /// files under `root_module.parent` can belong
+ /// to a crate. `include_dirs` are included
+ /// recursively, unless a subdirectory is in
+ /// `exclude_dirs`.
+ ///
+ /// Different crates can share the same `source`.
+ ///
+ /// If two crates share an `.rs` file in common,
+ /// they *must* have the same `source`.
+ /// rust-analyzer assumes that files from one
+ /// source can't refer to files in another source.
+ source?: {
+ include_dirs: string[],
+ exclude_dirs: string[],
+ },
+ /// The set of cfgs activated for a given crate, like
+ /// `["unix", "feature=\"foo\"", "feature=\"bar\""]`.
+ cfg: string[];
+ /// Target triple for this Crate.
+ ///
+ /// Used when running `rustc --print cfg`
+ /// to get target-specific cfgs.
+ target?: string;
+ /// Environment variables, used for
+ /// the `env!` macro
+ env: { [key: string]: string; },
+
+ /// Whether the crate is a proc-macro crate.
+ is_proc_macro: boolean;
+ /// For proc-macro crates, path to compiled
+ /// proc-macro (.so file).
+ proc_macro_dylib_path?: string;
+}
+
+interface Dep {
+ /// Index of a crate in the `crates` array.
+ crate: number,
+ /// Name as should appear in the (implicit)
+ /// `extern crate name` declaration.
+ name: string,
+}
+This format is provisional and subject to change. Specifically, the
+roots setup will be different eventually.
There are three ways to feed rust-project.json to rust-analyzer:
-
+
-
+
Place
+rust-project.jsonfile at the root of the project, and +rust-analyzer will discover it.
+ -
+
Specify +
+"rust-analyzer.linkedProjects": [ "path/to/rust-project.json" ]in +the settings (and make sure that your LSP client sends settings as a +part of initialize request).
+ -
+
Specify +
+"rust-analyzer.linkedProjects": [ { "roots": […], "crates": […] }]+inline.
+
Relative paths are interpreted relative to rust-project.json file
+location or (for inline JSON) relative to rootUri.
See https://github.com/rust-analyzer/rust-project.json-example for a +small example.
+You can set the RA_LOG environment variable to rust_analyzer=info to
+inspect how rust-analyzer handles config and project loading.
Note that calls to cargo check are disabled when using
+rust-project.json by default, so compilation errors and warnings will
+no longer be sent to your LSP client. To enable these compilation errors
+you will need to specify explicitly what command rust-analyzer should
+run to perform the checks using the
+rust-analyzer.check.overrideCommand configuration. As an example, the
+following configuration explicitly sets cargo check as the check
+command.
{ "rust-analyzer.check.overrideCommand": ["cargo", "check", "--message-format=json"] }
+check.overrideCommand requires the command specified to output json
+error messages for rust-analyzer to consume. The --message-format=json
+flag does this for cargo check so whichever command you use must also
+output errors in this format. See the Configuration
+section for more information.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/book/book/privacy/index.html b/docs/book/book/privacy/index.html
new file mode 100644
index 000000000000..22c4645b6812
--- /dev/null
+++ b/docs/book/book/privacy/index.html
@@ -0,0 +1,225 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Special
+
+
+
+
+ rust-analyzer
+At its core, rust-analyzer is a library for semantic analysis of +Rust code as it changes over time. This manual focuses on a specific +usage of the library — running it as part of a server that implements +the Language Server +Protocol (LSP). +The LSP allows various code editors, like VS Code, Emacs or Vim, to +implement semantic features like completion or goto definition by +talking to an external language server process.
+To improve this document, send a pull request:
+https://github.com/rust-analyzer/…/manual.adoc
The manual is written in AsciiDoc and includes
+some extra files which are generated from the source code. Run
+cargo test and cargo test -p xtask to create these and then
+asciidoctor manual.adoc to create an HTML copy.
If you have questions about using rust-analyzer, please ask them in the +“IDEs and Editors” topic of Rust +users forum.
+Installation
+In theory, one should be able to just install the rust-analyzer
+binary and have it automatically
+work with any editor. We are not there yet, so some editor specific
+setup is required.
Additionally, rust-analyzer needs the sources of the standard library. +If the source code is not present, rust-analyzer will attempt to install +it automatically.
+To add the sources manually, run the following command:
+$ rustup component add rust-src
+Toolchain
+Only the latest stable standard library source is officially supported +for use with rust-analyzer. If you are using an older toolchain or have +an override set, rust-analyzer may fail to understand the Rust source. +You will either need to update your toolchain or use an older version of +rust-analyzer that is compatible with your toolchain.
+If you are using an override in your project, you can still force
+rust-analyzer to use the stable toolchain via the environment variable
+RUSTUP_TOOLCHAIN. For example, with VS Code or coc-rust-analyzer:
{ "rust-analyzer.server.extraEnv": { "RUSTUP_TOOLCHAIN": "stable" } }
+VS Code
+This is the best supported editor at the moment. The rust-analyzer +plugin for VS Code is maintained in +tree.
+You can install the latest release of the plugin from the +marketplace.
+Note that the plugin may cause conflicts with the previous official +Rust +plugin. +The latter is no longer maintained and should be uninstalled.
+The server binary is stored in the extension install directory, which
+starts with rust-lang.rust-analyzer- and is located under:
-
+
-
+
Linux:
+~/.vscode/extensions
+ -
+
Linux (Remote, such as WSL):
+~/.vscode-server/extensions
+ -
+
macOS:
+~/.vscode/extensions
+ -
+
Windows:
+%USERPROFILE%\.vscode\extensions
+
As an exception, on NixOS, the extension makes a copy of the server and
+stores it under
+~/.config/Code/User/globalStorage/rust-lang.rust-analyzer.
Note that we only support the two most recent versions of VS Code.
+Updates
+The extension will be updated automatically as new versions become +available. It will ask your permission to download the matching language +server version binary if needed.
+Nightly
+We ship nightly releases for VS Code. To help us out by testing the +newest code, you can enable pre-release versions in the Code extension +page.
+Manual installation
+Alternatively, download a VSIX corresponding to your platform from the +releases page.
+Install the extension with the Extensions: Install from VSIX command
+within VS Code, or from the command line via:
$ code --install-extension /path/to/rust-analyzer.vsix
+If you are running an unsupported platform, you can install
+rust-analyzer-no-server.vsix and compile or obtain a server binary.
+Copy the server anywhere, then add the path to your settings.json, for
+example:
{ "rust-analyzer.server.path": "~/.local/bin/rust-analyzer-linux" }
+Building From Source
+Both the server and the Code plugin can be installed from source:
+$ git clone https://github.com/rust-lang/rust-analyzer.git && cd rust-analyzer
+$ cargo xtask install
+You’ll need Cargo, nodejs (matching a supported version of VS Code) and +npm for this.
+Note that installing via xtask install does not work for VS Code
+Remote, instead you’ll need to install the .vsix manually.
If you’re not using Code, you can compile and install only the LSP +server:
+$ cargo xtask install --server
+Make sure that .cargo/bin is in $PATH and precedes paths where
+rust-analyzer may also be installed. Specifically, rustup includes a
+proxy called rust-analyzer, which can cause problems if you’re
+planning to use a source build or even a downloaded binary.
rust-analyzer Language Server Binary
+Other editors generally require the rust-analyzer binary to be in
+$PATH. You can download pre-built binaries from the
+releases page.
+You will need to uncompress and rename the binary for your platform,
+e.g. from rust-analyzer-aarch64-apple-darwin.gz on Mac OS to
+rust-analyzer, make it executable, then move it into a directory in
+your $PATH.
On Linux to install the rust-analyzer binary into ~/.local/bin,
+these commands should work:
$ mkdir -p ~/.local/bin
+$ curl -L https://github.com/rust-lang/rust-analyzer/releases/latest/download/rust-analyzer-x86_64-unknown-linux-gnu.gz | gunzip -c - > ~/.local/bin/rust-analyzer
+$ chmod +x ~/.local/bin/rust-analyzer
+Make sure that ~/.local/bin is listed in the $PATH variable and use
+the appropriate URL if you’re not on a x86-64 system.
You don’t have to use ~/.local/bin, any other path like ~/.cargo/bin
+or /usr/local/bin will work just as well.
Alternatively, you can install it from source using the command below. +You’ll need the latest stable version of the Rust toolchain.
+$ git clone https://github.com/rust-lang/rust-analyzer.git && cd rust-analyzer
+$ cargo xtask install --server
+If your editor can’t find the binary even though the binary is on your
+$PATH, the likely explanation is that it doesn’t see the same $PATH
+as the shell, see this
+issue. On Unix,
+running the editor from a shell or changing the .desktop file to set
+the environment should help.
rustup
+rust-analyzer is available in rustup:
$ rustup component add rust-analyzer
+Arch Linux
+The rust-analyzer binary can be installed from the repos or AUR (Arch
+User Repository):
-
+
-
+
+rust-analyzer+(built from latest tagged source)
+ -
+
+rust-analyzer-git+(latest Git version)
+
Install it with pacman, for example:
+$ pacman -S rust-analyzer
+Gentoo Linux
+rust-analyzer is available in the GURU repository:
-
+
-
+
+dev-util/rust-analyzer+builds from source
+ -
+
+dev-util/rust-analyzer-bin+installs an official binary release
+
If not already, GURU must be enabled (e.g. using
+app-eselect/eselect-repository) and sync’d before running emerge:
$ eselect repository enable guru && emaint sync -r guru
+$ emerge rust-analyzer-bin
+macOS
+The rust-analyzer binary can be installed via
+Homebrew.
$ brew install rust-analyzer
+VS Code or VSCodium in Flatpak
+Setting up rust-analyzer with a Flatpak version of Code is not trivial
+because of the Flatpak sandbox. While the sandbox can be disabled for
+some directories, /usr/bin will always be mounted under
+/run/host/usr/bin. This prevents access to the system’s C compiler, a
+system-wide installation of Rust, or any other libraries you might want
+to link to. Some compilers and libraries can be acquired as Flatpak
+SDKs, such as org.freedesktop.Sdk.Extension.rust-stable or
+org.freedesktop.Sdk.Extension.llvm15.
If you use a Flatpak SDK for Rust, there should be no extra steps +necessary.
+If you want to use Flatpak in combination with rustup, the following
+steps might help:
-
+
-
+
both Rust and
+rustuphave to be installed using +https://rustup.rs. Distro packages will not work.
+ -
+
you need to launch Code, open a terminal and run
+echo $PATH
+ -
+
using +Flatseal, +you must add an environment variable called
+PATH. Set its value to +the output from above, appending:~/.cargo/bin, where~is the +path to your home directory. You must replace~, as it won’t be +expanded otherwise.
+ -
+
while Flatseal is open, you must enable access to "All user files"
+
+
A C compiler should already be available via org.freedesktop.Sdk. Any
+other tools or libraries you will need to acquire from Flatpak.
Emacs
+Prerequisites: You have installed the rust-analyzer
+binary.
To use rust-analyzer, you need to install and enable one of the two
+popular LSP client implementations for Emacs,
+Eglot or LSP
+Mode. Both enable
+rust-analyzer by default in rust buffers if it is available.
Eglot
+Eglot is the more minimalistic and lightweight LSP client for Emacs, +integrates well with existing Emacs functionality and is built into +Emacs starting from release 29.
+After installing Eglot, e.g. via M-x package-install (not needed from
+Emacs 29), you can enable it via the M-x eglot command or load it
+automatically in rust-mode via
(add-hook 'rust-mode-hook 'eglot-ensure)
+To enable clippy, you will need to configure the initialization options
+to pass the check.command setting.
(add-to-list 'eglot-server-programs
+ '((rust-ts-mode rust-mode) .
+ ("rust-analyzer" :initializationOptions (:check (:command "clippy")))))
+For more detailed instructions and options see the Eglot
+manual (also available from Emacs
+via M-x info) and the Eglot
+readme.
Eglot does not support the rust-analyzer extensions to the +language-server protocol and does not aim to do so in the future. The +eglot-x +package adds experimental support for those LSP extensions.
+LSP Mode
+LSP-mode is the original LSP-client for emacs. Compared to Eglot it has +a larger codebase and supports more features, like LSP protocol +extensions. With extension packages like LSP +UI it offers a lot of visual +eyecandy. Further it integrates well with DAP +mode for support of the Debug +Adapter Protocol.
+You can install LSP-mode via M-x package-install and then run it via
+the M-x lsp command or load it automatically in rust buffers with
(add-hook 'rust-mode-hook 'lsp-deferred)
+For more information on how to set up LSP mode and its extension package
+see the instructions in the LSP mode
+manual. Also
+see the rust-analyzer
+section
+for rust-analyzer specific options and commands, which you can
+optionally bind to keys.
Note the excellent +guide from +@rksm on how to set-up Emacs for Rust +development with LSP mode and several other packages.
+Vim/Neovim
+Prerequisites: You have installed the rust-analyzer
+binary. Not needed if the
+extension can install/update it on its own, coc-rust-analyzer is one
+example.
There are several LSP client implementations for Vim or Neovim:
+coc-rust-analyzer
+-
+
-
+
Install coc.nvim by following the instructions at +coc.nvim (Node.js required)
+
+ -
+
Run
+:CocInstall coc-rust-analyzerto install +coc-rust-analyzer, +this extension implements most of the features supported in the +VSCode extension:-
+
-
+
automatically install and upgrade stable/nightly releases
+
+ -
+
same configurations as VSCode extension, +
+rust-analyzer.server.path,rust-analyzer.cargo.featuresetc.
+ -
+
same commands too,
+rust-analyzer.analyzerStatus, +rust-analyzer.ssretc.
+ -
+
inlay hints for variables and method chaining, Neovim Only
+
+
+ -
+
Note: for code actions, use coc-codeaction-cursor and
+coc-codeaction-selected; coc-codeaction and coc-codeaction-line
+are unlikely to be useful.
LanguageClient-neovim
+-
+
-
+
Install LanguageClient-neovim by following the instructions +here
+-
+
- The GitHub project wiki has extra tips on configuration +
+ -
+
Configure by adding this to your Vim/Neovim config file (replacing +the existing Rust-specific line if it exists):
+
+let g:LanguageClient_serverCommands = { +\ 'rust': ['rust-analyzer'], +\ } +
+
YouCompleteMe
+Install YouCompleteMe by following the instructions +here.
+rust-analyzer is the default in ycm, it should work out of the box.
+ALE
+To use the LSP server in ale:
+let g:ale_linters = {'rust': ['analyzer']}
+nvim-lsp
+Neovim 0.5 has built-in language server support. For a quick start
+configuration of rust-analyzer, use
+neovim/nvim-lspconfig.
+Once neovim/nvim-lspconfig is installed, use
+lua require'lspconfig'.rust_analyzer.setup({}) in your init.vim.
You can also pass LSP settings to the server:
+lua << EOF
+local nvim_lsp = require'lspconfig'
+
+local on_attach = function(client)
+ require'completion'.on_attach(client)
+end
+
+nvim_lsp.rust_analyzer.setup({
+ on_attach=on_attach,
+ settings = {
+ ["rust-analyzer"] = {
+ imports = {
+ granularity = {
+ group = "module",
+ },
+ prefix = "self",
+ },
+ cargo = {
+ buildScripts = {
+ enable = true,
+ },
+ },
+ procMacro = {
+ enable = true
+ },
+ }
+ }
+})
+EOF
+See https://sharksforarms.dev/posts/neovim-rust/ for more tips on +getting started.
+Check out https://github.com/simrat39/rust-tools.nvim for a batteries +included rust-analyzer setup for Neovim.
+vim-lsp
+vim-lsp is installed by following the plugin
+instructions. It can be as
+simple as adding this line to your .vimrc:
Plug 'prabirshrestha/vim-lsp'
+Next you need to register the rust-analyzer binary. If it is available
+in $PATH, you may want to add this to your .vimrc:
if executable('rust-analyzer')
+ au User lsp_setup call lsp#register_server({
+ \ 'name': 'Rust Language Server',
+ \ 'cmd': {server_info->['rust-analyzer']},
+ \ 'whitelist': ['rust'],
+ \ })
+endif
+There is no dedicated UI for the server configuration, so you would need
+to send any options as a value of the initialization_options field, as
+described in the Configuration section. Here is an
+example of how to enable the proc-macro support:
if executable('rust-analyzer')
+ au User lsp_setup call lsp#register_server({
+ \ 'name': 'Rust Language Server',
+ \ 'cmd': {server_info->['rust-analyzer']},
+ \ 'whitelist': ['rust'],
+ \ 'initialization_options': {
+ \ 'cargo': {
+ \ 'buildScripts': {
+ \ 'enable': v:true,
+ \ },
+ \ },
+ \ 'procMacro': {
+ \ 'enable': v:true,
+ \ },
+ \ },
+ \ })
+endif
+Sublime Text
+Sublime Text 4:
+-
+
- Follow the instructions in +LSP-rust-analyzer. +
Install
+LSP-file-watcher-chokidar
+to enable file watching (workspace/didChangeWatchedFiles).
Sublime Text 3:
+-
+
-
+
Install the
+rust-analyzer+binary.
+ -
+
Install the LSP package.
+
+ -
+
From the command palette, run
+LSP: Enable Language Server Globally+and selectrust-analyzer.
+
If it worked, you should see "rust-analyzer, Line X, Column Y" on the +left side of the status bar, and after waiting a bit, functionalities +like tooltips on hovering over variables should become available.
+If you get an error saying No such file or directory: 'rust-analyzer',
+see the rust-analyzer binary
+section on installing the language server binary.
GNOME Builder
+GNOME Builder 3.37.1 and newer has native rust-analyzer support. If
+the LSP binary is not available, GNOME Builder can install it when
+opening a Rust file.
Eclipse IDE
+Support for Rust development in the Eclipse IDE is provided by Eclipse
+Corrosion. If available in PATH
+or in some standard location, rust-analyzer is detected and powers
+editing of Rust files without further configuration. If rust-analyzer
+is not detected, Corrosion will prompt you for configuration of your
+Rust toolchain and language server with a link to the Window >
+Preferences > Rust preference page; from here a button allows to
+download and configure rust-analyzer, but you can also reference
+another installation. You’ll need to close and reopen all .rs and Cargo
+files, or to restart the IDE, for this change to take effect.
Kate Text Editor
+Support for the language server protocol is built into Kate through the +LSP plugin, which is included by default. It is preconfigured to use +rust-analyzer for Rust sources since Kate 21.12.
+To change rust-analyzer config options, start from the following example +and put it into Kate’s "User Server Settings" tab (located under the LSP +Client settings):
+{
+ "servers": {
+ "rust": {
+ "initializationOptions": {
+ "cachePriming": {
+ "enable": false
+ },
+ "check": {
+ "allTargets": false
+ },
+ "checkOnSave": false
+ }
+ }
+ }
+}
+Then click on apply, and restart the LSP server for your rust project.
+juCi++
+juCi++ has built-in support for the +language server protocol, and since version 1.7.0 offers installation of +both Rust and rust-analyzer when opening a Rust file.
+Kakoune
+Kakoune supports LSP with the help of
+kak-lsp. Follow the
+instructions to
+install kak-lsp. To configure kak-lsp, refer to the configuration
+section which
+is basically about copying the configuration
+file in
+the right place (latest versions should use rust-analyzer by default).
Finally, you need to configure Kakoune to talk to kak-lsp (see Usage
+section). A basic
+configuration will only get you LSP but you can also activate inlay
+diagnostics and auto-formatting on save. The following might help you
+get all of this.
eval %sh{kak-lsp --kakoune -s $kak_session} # Not needed if you load it with plug.kak.
+hook global WinSetOption filetype=rust %{
+ # Enable LSP
+ lsp-enable-window
+
+ # Auto-formatting on save
+ hook window BufWritePre .* lsp-formatting-sync
+
+ # Configure inlay hints (only on save)
+ hook window -group rust-inlay-hints BufWritePost .* rust-analyzer-inlay-hints
+ hook -once -always window WinSetOption filetype=.* %{
+ remove-hooks window rust-inlay-hints
+ }
+}
+Helix
+Helix supports LSP by default.
+However, it won’t install rust-analyzer automatically. You can follow
+instructions for installing rust-analyzer
+binary.
Visual Studio 2022
+There are multiple rust-analyzer extensions for Visual Studio 2022 on +Windows:
+rust-analyzer.vs
+(License: Creative Commons Attribution-NonCommercial-ShareAlike 4.0 +International)
+ + +Support for Rust development in the Visual Studio IDE is enabled by the +rust-analyzer +package. Either click on the download link or install from IDE’s +extension manager. For now Visual Studio +2022 is required. All +editions are supported viz. Community, Professional & Enterprise. The +package aims to provide 0-friction installation and therefore comes +loaded with most things required including rust-analyzer binary. If +anything it needs is missing, appropriate errors / warnings will guide +the user. E.g. cargo.exe needs to be in path and the package will tell +you as much. This package is under rapid active development. So if you +encounter any issues please file it at +rust-analyzer.vs.
+VS_RustAnalyzer
+(License: GPL)
+ + +SourceGear Rust
+(License: closed source)
+ +GitHub (docs, issues, +discussions)
+-
+
-
+
Free (no-cost)
+
+ -
+
Supports all editions of Visual Studio 2022 on Windows: Community, +Professional, or Enterprise
+
+
Lapce
+Lapce has a Rust plugin which you can install
+directly. Unfortunately, it downloads an old version of rust-analyzer,
+but you can set the server path under Settings.
Crates
+There is a package named ra_ap_rust_analyzer available on
+crates.io, for someone
+who wants to use it programmatically.
For more details, see the publish +workflow.
+Zed
+Zed has native rust-analyzer support. If the LSP
+binary is not available, Zed can install it when opening a Rust file.
Troubleshooting
+Start with looking at the rust-analyzer version. Try rust-analyzer:
+Show RA Version in VS Code (using Command Palette feature
+typically activated by Ctrl+Shift+P) or rust-analyzer --version in the
+command line. If the date is more than a week ago, it’s better to update
+rust-analyzer version.
The next thing to check would be panic messages in rust-analyzer’s log.
+Log messages are printed to stderr, in VS Code you can see them in the
+Output > Rust Analyzer Language Server tab of the panel. To see more
+logs, set the RA_LOG=info environment variable, this can be done
+either by setting the environment variable manually or by using
+rust-analyzer.server.extraEnv, note that both of these approaches
+require the server to be restarted.
To fully capture LSP messages between the editor and the server, set
+"rust-analyzer.trace.server": "verbose" config and check
+Output > Rust Analyzer Language Server Trace.
The root cause for many “nothing works” problems is that rust-analyzer
+fails to understand the project structure. To debug that, first note the
+rust-analyzer section in the status bar. If it has an error icon and
+red, that’s the problem (hover will have somewhat helpful error
+message). rust-analyzer: Status prints dependency information for
+the current file. Finally, RA_LOG=project_model=debug enables verbose
+logs during project loading.
If rust-analyzer outright crashes, try running
+rust-analyzer analysis-stats /path/to/project/directory/ on the
+command line. This command type checks the whole project in batch mode
+bypassing LSP machinery.
When filing issues, it is useful (but not necessary) to try to minimize +examples. An ideal bug reproduction looks like this:
+$ git clone https://github.com/username/repo.git && cd repo && git switch --detach commit-hash
+$ rust-analyzer --version
+rust-analyzer dd12184e4 2021-05-08 dev
+$ rust-analyzer analysis-stats .
+💀 💀 💀
+It is especially useful when the repo doesn’t use external crates or
+the standard library.
If you want to go as far as to modify the source code to debug the +problem, be sure to take a look at the dev +docs!
+Configuration
+Source: +config.rs
+The Installation section contains details on
+configuration for some of the editors. In general rust-analyzer is
+configured via LSP messages, which means that it’s up to the editor to
+decide on the exact format and location of configuration files.
Some clients, such as VS Code or COC plugin in
+Vim provide rust-analyzer specific configuration
+UIs. Others may require you to know a bit more about the interaction
+with rust-analyzer.
For the later category, it might help to know that the initial
+configuration is specified as a value of the initializationOptions
+field of the InitializeParams message, in the LSP
+protocol.
+The spec says that the field type is any?, but rust-analyzer is
+looking for a JSON object that is constructed using settings from the
+list below. Name of the setting, ignoring the rust-analyzer. prefix,
+is used as a path, and value of the setting becomes the JSON property
+value.
For example, a very common configuration is to enable proc-macro +support, can be achieved by sending this JSON:
+{
+ "cargo": {
+ "buildScripts": {
+ "enable": true,
+ },
+ },
+ "procMacro": {
+ "enable": true,
+ }
+}
+Please consult your editor’s documentation to learn more about how to +configure LSP +servers.
+To verify which configuration is actually used by rust-analyzer, set
+RA_LOG environment variable to rust_analyzer=info and look for
+config-related messages. Logs should show both the JSON that
+rust-analyzer sees as well as the updated config.
This is the list of config options rust-analyzer supports:
rust-analyzer.assist.emitMustUse (default: false)
+Whether to insert #[must_use] when generating as_ methods
+for enum variants.
rust-analyzer.assist.expressionFillDefault (default: "todo")
+Placeholder expression to use for missing expressions in assists.
+rust-analyzer.cachePriming.enable (default: true)
+Warm up caches on project load.
+rust-analyzer.cachePriming.numThreads (default: 0)
+How many worker threads to handle priming caches. The default 0 means to pick automatically.
rust-analyzer.cargo.autoreload (default: true)
+Automatically refresh project info via cargo metadata on
+Cargo.toml or .cargo/config.toml changes.
rust-analyzer.cargo.buildScripts.enable (default: true)
+Run build scripts (build.rs) for more precise code analysis.
rust-analyzer.cargo.buildScripts.invocationLocation (default: "workspace")
+Specifies the working directory for running build scripts.
+-
+
- "workspace": run build scripts for a workspace in the workspace's root directory.
+This is incompatible with
#rust-analyzer.cargo.buildScripts.invocationStrategy#set toonce.
+ - "root": run build scripts in the project's root directory.
+This config only has an effect when
#rust-analyzer.cargo.buildScripts.overrideCommand#+is set.
+
rust-analyzer.cargo.buildScripts.invocationStrategy (default: "per_workspace")
+Specifies the invocation strategy to use when running the build scripts command.
+If per_workspace is set, the command will be executed for each workspace.
+If once is set, the command will be executed once.
+This config only has an effect when #rust-analyzer.cargo.buildScripts.overrideCommand#
+is set.
rust-analyzer.cargo.buildScripts.overrideCommand (default: null)
+Override the command rust-analyzer uses to run build scripts and
+build procedural macros. The command is required to output json
+and should therefore include --message-format=json or a similar
+option.
If there are multiple linked projects/workspaces, this command is invoked for
+each of them, with the working directory being the workspace root
+(i.e., the folder containing the Cargo.toml). This can be overwritten
+by changing #rust-analyzer.cargo.buildScripts.invocationStrategy# and
+#rust-analyzer.cargo.buildScripts.invocationLocation#.
By default, a cargo invocation will be constructed for the configured +targets and features, with the following base command line:
+cargo check --quiet --workspace --message-format=json --all-targets
+.
+rust-analyzer.cargo.buildScripts.useRustcWrapper (default: true)
+Use RUSTC_WRAPPER=rust-analyzer when running build scripts to
+avoid checking unnecessary things.
rust-analyzer.cargo.cfgs (default: {})
+List of cfg options to enable with the given values.
+rust-analyzer.cargo.extraArgs (default: [])
+Extra arguments that are passed to every cargo invocation.
+rust-analyzer.cargo.extraEnv (default: {})
+Extra environment variables that will be set when running cargo, rustc +or other commands within the workspace. Useful for setting RUSTFLAGS.
+rust-analyzer.cargo.features (default: [])
+List of features to activate.
+Set this to "all" to pass --all-features to cargo.
rust-analyzer.cargo.noDefaultFeatures (default: false)
+Whether to pass --no-default-features to cargo.
rust-analyzer.cargo.sysroot (default: "discover")
+Relative path to the sysroot, or "discover" to try to automatically find it via +"rustc --print sysroot".
+Unsetting this disables sysroot loading.
+This option does not take effect until rust-analyzer is restarted.
+rust-analyzer.cargo.sysrootSrc (default: null)
+Relative path to the sysroot library sources. If left unset, this will default to
+{cargo.sysroot}/lib/rustlib/src/rust/library.
This option does not take effect until rust-analyzer is restarted.
+rust-analyzer.cargo.target (default: null)
+Compilation target override (target triple).
+rust-analyzer.cargo.unsetTest (default: ["core"])
+Unsets the implicit #[cfg(test)] for the specified crates.
rust-analyzer.checkOnSave (default: true)
+Run the check command for diagnostics on save.
+rust-analyzer.check.allTargets (default: true)
+Check all targets and tests (--all-targets).
rust-analyzer.check.command (default: "check")
+Cargo command to use for cargo check.
rust-analyzer.check.extraArgs (default: [])
+Extra arguments for cargo check.
rust-analyzer.check.extraEnv (default: {})
+Extra environment variables that will be set when running cargo check.
+Extends #rust-analyzer.cargo.extraEnv#.
rust-analyzer.check.features (default: null)
+List of features to activate. Defaults to
+#rust-analyzer.cargo.features#.
Set to "all" to pass --all-features to Cargo.
rust-analyzer.check.ignore (default: [])
+List of cargo check (or other command specified in check.command) diagnostics to ignore.
For example for cargo check: dead_code, unused_imports, unused_variables,...
rust-analyzer.check.invocationLocation (default: "workspace")
+Specifies the working directory for running checks.
+-
+
- "workspace": run checks for workspaces in the corresponding workspaces' root directories.
+This falls back to "root" if
#rust-analyzer.cargo.check.invocationStrategy#is set toonce.
+ - "root": run checks in the project's root directory.
+This config only has an effect when
#rust-analyzer.cargo.check.overrideCommand#+is set.
+
rust-analyzer.check.invocationStrategy (default: "per_workspace")
+Specifies the invocation strategy to use when running the check command.
+If per_workspace is set, the command will be executed for each workspace.
+If once is set, the command will be executed once.
+This config only has an effect when #rust-analyzer.cargo.check.overrideCommand#
+is set.
rust-analyzer.check.noDefaultFeatures (default: null)
+Whether to pass --no-default-features to Cargo. Defaults to
+#rust-analyzer.cargo.noDefaultFeatures#.
rust-analyzer.check.overrideCommand (default: null)
+Override the command rust-analyzer uses instead of cargo check for
+diagnostics on save. The command is required to output json and
+should therefore include --message-format=json or a similar option
+(if your client supports the colorDiagnosticOutput experimental
+capability, you can use --message-format=json-diagnostic-rendered-ansi).
If you're changing this because you're using some tool wrapping
+Cargo, you might also want to change
+#rust-analyzer.cargo.buildScripts.overrideCommand#.
If there are multiple linked projects/workspaces, this command is invoked for
+each of them, with the working directory being the workspace root
+(i.e., the folder containing the Cargo.toml). This can be overwritten
+by changing #rust-analyzer.cargo.check.invocationStrategy# and
+#rust-analyzer.cargo.check.invocationLocation#.
An example command would be:
+cargo check --workspace --message-format=json --all-targets
+.
+rust-analyzer.check.targets (default: null)
+Check for specific targets. Defaults to #rust-analyzer.cargo.target# if empty.
Can be a single target, e.g. "x86_64-unknown-linux-gnu" or a list of targets, e.g.
+["aarch64-apple-darwin", "x86_64-apple-darwin"].
Aliased as "checkOnSave.targets".
rust-analyzer.completion.autoimport.enable (default: true)
+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.
rust-analyzer.completion.autoself.enable (default: true)
+Toggles the additional completions that automatically show method calls and field accesses
+with self prefixed to them when inside a method.
rust-analyzer.completion.callable.snippets (default: "fill_arguments")
+Whether to add parenthesis and argument snippets when completing function.
+rust-analyzer.completion.fullFunctionSignatures.enable (default: false)
+Whether to show full function/method signatures in completion docs.
+rust-analyzer.completion.limit (default: null)
+Maximum number of completions to return. If None, the limit is infinite.
rust-analyzer.completion.postfix.enable (default: true)
+Whether to show postfix snippets like dbg, if, not, etc.
rust-analyzer.completion.privateEditable.enable (default: false)
+Enables completions of private items and fields that are defined in the current workspace even if they are not visible at the current position.
+rust-analyzer.completion.snippets.custom
+Default:
+ "Arc::new": {
+ "postfix": "arc",
+ "body": "Arc::new(${receiver})",
+ "requires": "std::sync::Arc",
+ "description": "Put the expression into an `Arc`",
+ "scope": "expr"
+ },
+ "Rc::new": {
+ "postfix": "rc",
+ "body": "Rc::new(${receiver})",
+ "requires": "std::rc::Rc",
+ "description": "Put the expression into an `Rc`",
+ "scope": "expr"
+ },
+ "Box::pin": {
+ "postfix": "pinbox",
+ "body": "Box::pin(${receiver})",
+ "requires": "std::boxed::Box",
+ "description": "Put the expression into a pinned `Box`",
+ "scope": "expr"
+ },
+ "Ok": {
+ "postfix": "ok",
+ "body": "Ok(${receiver})",
+ "description": "Wrap the expression in a `Result::Ok`",
+ "scope": "expr"
+ },
+ "Err": {
+ "postfix": "err",
+ "body": "Err(${receiver})",
+ "description": "Wrap the expression in a `Result::Err`",
+ "scope": "expr"
+ },
+ "Some": {
+ "postfix": "some",
+ "body": "Some(${receiver})",
+ "description": "Wrap the expression in an `Option::Some`",
+ "scope": "expr"
+ }
+ }
+
+Custom completion snippets.
+rust-analyzer.diagnostics.disabled (default: [])
+List of rust-analyzer diagnostics to disable.
+rust-analyzer.diagnostics.enable (default: true)
+Whether to show native rust-analyzer diagnostics.
+rust-analyzer.diagnostics.experimental.enable (default: false)
+Whether to show experimental rust-analyzer diagnostics that might +have more false positives than usual.
+rust-analyzer.diagnostics.remapPrefix (default: {})
+Map of prefixes to be substituted when parsing diagnostic file paths.
+This should be the reverse mapping of what is passed to rustc as --remap-path-prefix.
rust-analyzer.diagnostics.warningsAsHint (default: [])
+List of warnings that should be displayed with hint severity.
+The warnings will be indicated by faded text or three dots in code
+and will not show up in the Problems Panel.
rust-analyzer.diagnostics.warningsAsInfo (default: [])
+List of warnings that should be displayed with info severity.
+The warnings will be indicated by a blue squiggly underline in code
+and a blue icon in the Problems Panel.
rust-analyzer.files.excludeDirs (default: [])
+These directories will be ignored by rust-analyzer. They are
+relative to the workspace root, and globs are not supported. You may
+also need to add the folders to Code's files.watcherExclude.
rust-analyzer.files.watcher (default: "client")
+Controls file watching implementation.
+rust-analyzer.highlightRelated.breakPoints.enable (default: true)
+Enables highlighting of related references while the cursor is on break, loop, while, or for keywords.
rust-analyzer.highlightRelated.closureCaptures.enable (default: true)
+Enables highlighting of all captures of a closure while the cursor is on the | or move keyword of a closure.
rust-analyzer.highlightRelated.exitPoints.enable (default: true)
+Enables highlighting of all exit points while the cursor is on any return, ?, fn, or return type arrow (->).
rust-analyzer.highlightRelated.references.enable (default: true)
+Enables highlighting of related references while the cursor is on any identifier.
+rust-analyzer.highlightRelated.yieldPoints.enable (default: true)
+Enables highlighting of all break points for a loop or block context while the cursor is on any async or await keywords.
rust-analyzer.hover.actions.debug.enable (default: true)
+Whether to show Debug action. Only applies when
+#rust-analyzer.hover.actions.enable# is set.
rust-analyzer.hover.actions.enable (default: true)
+Whether to show HoverActions in Rust files.
+rust-analyzer.hover.actions.gotoTypeDef.enable (default: true)
+Whether to show Go to Type Definition action. Only applies when
+#rust-analyzer.hover.actions.enable# is set.
rust-analyzer.hover.actions.implementations.enable (default: true)
+Whether to show Implementations action. Only applies when
+#rust-analyzer.hover.actions.enable# is set.
rust-analyzer.hover.actions.references.enable (default: false)
+Whether to show References action. Only applies when
+#rust-analyzer.hover.actions.enable# is set.
rust-analyzer.hover.actions.run.enable (default: true)
+Whether to show Run action. Only applies when
+#rust-analyzer.hover.actions.enable# is set.
rust-analyzer.hover.documentation.enable (default: true)
+Whether to show documentation on hover.
+rust-analyzer.hover.documentation.keywords.enable (default: true)
+Whether to show keyword hover popups. Only applies when
+#rust-analyzer.hover.documentation.enable# is set.
rust-analyzer.hover.links.enable (default: true)
+Use markdown syntax for links on hover.
+rust-analyzer.hover.memoryLayout.alignment (default: "hexadecimal")
+How to render the align information in a memory layout hover.
+rust-analyzer.hover.memoryLayout.enable (default: true)
+Whether to show memory layout data on hover.
+rust-analyzer.hover.memoryLayout.niches (default: false)
+How to render the niche information in a memory layout hover.
+rust-analyzer.hover.memoryLayout.offset (default: "hexadecimal")
+How to render the offset information in a memory layout hover.
+rust-analyzer.hover.memoryLayout.size (default: "both")
+How to render the size information in a memory layout hover.
+rust-analyzer.imports.granularity.enforce (default: false)
+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.
+rust-analyzer.imports.granularity.group (default: "crate")
+How imports should be grouped into use statements.
+rust-analyzer.imports.group.enable (default: true)
+Group inserted imports by the following order. Groups are separated by newlines.
+rust-analyzer.imports.merge.glob (default: true)
+Whether to allow import insertion to merge new imports into single path glob imports like use std::fmt::*;.
rust-analyzer.imports.prefer.no.std (default: false)
+Prefer to unconditionally use imports of the core and alloc crate, over the std crate.
+rust-analyzer.imports.prefix (default: "plain")
+The path structure for newly inserted paths to use.
+rust-analyzer.inlayHints.bindingModeHints.enable (default: false)
+Whether to show inlay type hints for binding modes.
+rust-analyzer.inlayHints.chainingHints.enable (default: true)
+Whether to show inlay type hints for method chains.
+rust-analyzer.inlayHints.closingBraceHints.enable (default: true)
+Whether to show inlay hints after a closing } to indicate what item it belongs to.
rust-analyzer.inlayHints.closingBraceHints.minLines (default: 25)
+Minimum number of lines required before the } until the hint is shown (set to 0 or 1
+to always show them).
rust-analyzer.inlayHints.closureCaptureHints.enable (default: false)
+Whether to show inlay hints for closure captures.
+rust-analyzer.inlayHints.closureReturnTypeHints.enable (default: "never")
+Whether to show inlay type hints for return types of closures.
+rust-analyzer.inlayHints.closureStyle (default: "impl_fn")
+Closure notation in type and chaining inlay hints.
+rust-analyzer.inlayHints.discriminantHints.enable (default: "never")
+Whether to show enum variant discriminant hints.
+rust-analyzer.inlayHints.expressionAdjustmentHints.enable (default: "never")
+Whether to show inlay hints for type adjustments.
+rust-analyzer.inlayHints.expressionAdjustmentHints.hideOutsideUnsafe (default: false)
+Whether to hide inlay hints for type adjustments outside of unsafe blocks.
rust-analyzer.inlayHints.expressionAdjustmentHints.mode (default: "prefix")
+Whether to show inlay hints as postfix ops (.* instead of *, etc).
rust-analyzer.inlayHints.lifetimeElisionHints.enable (default: "never")
+Whether to show inlay type hints for elided lifetimes in function signatures.
+rust-analyzer.inlayHints.lifetimeElisionHints.useParameterNames (default: false)
+Whether to prefer using parameter names as the name for elided lifetime hints if possible.
+rust-analyzer.inlayHints.maxLength (default: 25)
+Maximum length for inlay hints. Set to null to have an unlimited length.
+rust-analyzer.inlayHints.parameterHints.enable (default: true)
+Whether to show function parameter name inlay hints at the call +site.
+rust-analyzer.inlayHints.reborrowHints.enable (default: "never")
+Whether to show inlay hints for compiler inserted reborrows. +This setting is deprecated in favor of #rust-analyzer.inlayHints.expressionAdjustmentHints.enable#.
+rust-analyzer.inlayHints.renderColons (default: true)
+Whether to render leading colons for type hints, and trailing colons for parameter hints.
+rust-analyzer.inlayHints.typeHints.enable (default: true)
+Whether to show inlay type hints for variables.
+rust-analyzer.inlayHints.typeHints.hideClosureInitialization (default: false)
+Whether to hide inlay type hints for let statements that initialize to a closure.
+Only applies to closures with blocks, same as #rust-analyzer.inlayHints.closureReturnTypeHints.enable#.
rust-analyzer.inlayHints.typeHints.hideNamedConstructor (default: false)
+Whether to hide inlay type hints for constructors.
+rust-analyzer.interpret.tests (default: false)
+Enables the experimental support for interpreting tests.
+rust-analyzer.joinLines.joinAssignments (default: true)
+Join lines merges consecutive declaration and initialization of an assignment.
+rust-analyzer.joinLines.joinElseIf (default: true)
+Join lines inserts else between consecutive ifs.
+rust-analyzer.joinLines.removeTrailingComma (default: true)
+Join lines removes trailing commas.
+rust-analyzer.joinLines.unwrapTrivialBlock (default: true)
+Join lines unwraps trivial blocks.
+rust-analyzer.lens.debug.enable (default: true)
+Whether to show Debug lens. Only applies when
+#rust-analyzer.lens.enable# is set.
rust-analyzer.lens.enable (default: true)
+Whether to show CodeLens in Rust files.
+rust-analyzer.lens.forceCustomCommands (default: true)
+Internal config: use custom client-side commands even when the +client doesn't set the corresponding capability.
+rust-analyzer.lens.implementations.enable (default: true)
+Whether to show Implementations lens. Only applies when
+#rust-analyzer.lens.enable# is set.
rust-analyzer.lens.location (default: "above_name")
+Where to render annotations.
+rust-analyzer.lens.references.adt.enable (default: false)
+Whether to show References lens for Struct, Enum, and Union.
+Only applies when #rust-analyzer.lens.enable# is set.
rust-analyzer.lens.references.enumVariant.enable (default: false)
+Whether to show References lens for Enum Variants.
+Only applies when #rust-analyzer.lens.enable# is set.
rust-analyzer.lens.references.method.enable (default: false)
+Whether to show Method References lens. Only applies when
+#rust-analyzer.lens.enable# is set.
rust-analyzer.lens.references.trait.enable (default: false)
+Whether to show References lens for Trait.
+Only applies when #rust-analyzer.lens.enable# is set.
rust-analyzer.lens.run.enable (default: true)
+Whether to show Run lens. Only applies when
+#rust-analyzer.lens.enable# is set.
rust-analyzer.linkedProjects (default: [])
+Disable project auto-discovery in favor of explicitly specified set +of projects.
+Elements must be paths pointing to Cargo.toml,
+rust-project.json, or JSON objects in rust-project.json format.
rust-analyzer.lru.capacity (default: null)
+Number of syntax trees rust-analyzer keeps in memory. Defaults to 128.
+rust-analyzer.lru.query.capacities (default: {})
+Sets the LRU capacity of the specified queries.
+rust-analyzer.notifications.cargoTomlNotFound (default: true)
+Whether to show can't find Cargo.toml error message.
rust-analyzer.numThreads (default: null)
+How many worker threads in the main loop. The default null means to pick automatically.
rust-analyzer.procMacro.attributes.enable (default: true)
+Expand attribute macros. Requires #rust-analyzer.procMacro.enable# to be set.
rust-analyzer.procMacro.enable (default: true)
+Enable support for procedural macros, implies #rust-analyzer.cargo.buildScripts.enable#.
rust-analyzer.procMacro.ignored (default: {})
+These proc-macros will be ignored when trying to expand them.
+This config takes a map of crate names with the exported proc-macro names to ignore as values.
+rust-analyzer.procMacro.server (default: null)
+Internal config, path to proc-macro server executable.
+rust-analyzer.references.excludeImports (default: false)
+Exclude imports from find-all-references.
+rust-analyzer.runnables.command (default: null)
+Command to be executed instead of 'cargo' for runnables.
+rust-analyzer.runnables.extraArgs (default: [])
+Additional arguments to be passed to cargo for runnables such as
+tests or binaries. For example, it may be --release.
rust-analyzer.rust.analyzerTargetDir (default: null)
+Optional path to a rust-analyzer specific target directory.
+This prevents rust-analyzer's cargo check from locking the Cargo.lock
+at the expense of duplicating build artifacts.
Set to true to use a subdirectory of the existing target directory or
+set to a path relative to the workspace to use that path.
rust-analyzer.rustc.source (default: null)
+Path to the Cargo.toml of the rust compiler workspace, for usage in rustc_private
+projects, or "discover" to try to automatically find it if the rustc-dev component
+is installed.
Any project which uses rust-analyzer with the rustcPrivate
+crates must set [package.metadata.rust-analyzer] rustc_private=true to use it.
This option does not take effect until rust-analyzer is restarted.
+rust-analyzer.rustfmt.extraArgs (default: [])
+Additional arguments to rustfmt.
rust-analyzer.rustfmt.overrideCommand (default: null)
+Advanced option, fully override the command rust-analyzer uses for
+formatting. This should be the equivalent of rustfmt here, and
+not that of cargo fmt. The file contents will be passed on the
+standard input and the formatted result will be read from the
+standard output.
rust-analyzer.rustfmt.rangeFormatting.enable (default: false)
+Enables the use of rustfmt's unstable range formatting command for the
+textDocument/rangeFormatting request. The rustfmt option is unstable and only
+available on a nightly build.
rust-analyzer.semanticHighlighting.doc.comment.inject.enable (default: true)
+Inject additional highlighting into doc comments.
+When enabled, rust-analyzer will highlight rust source in doc comments as well as intra +doc links.
+rust-analyzer.semanticHighlighting.nonStandardTokens (default: true)
+Whether the server is allowed to emit non-standard tokens and modifiers.
+rust-analyzer.semanticHighlighting.operator.enable (default: true)
+Use semantic tokens for operators.
+When disabled, rust-analyzer will emit semantic tokens only for operator tokens when +they are tagged with modifiers.
+rust-analyzer.semanticHighlighting.operator.specialization.enable (default: false)
+Use specialized semantic tokens for operators.
+When enabled, rust-analyzer will emit special token types for operator tokens instead
+of the generic operator token type.
rust-analyzer.semanticHighlighting.punctuation.enable (default: false)
+Use semantic tokens for punctuation.
+When disabled, rust-analyzer will emit semantic tokens only for punctuation tokens when +they are tagged with modifiers or have a special role.
+rust-analyzer.semanticHighlighting.punctuation.separate.macro.bang (default: false)
+When enabled, rust-analyzer will emit a punctuation semantic token for the ! of macro
+calls.
rust-analyzer.semanticHighlighting.punctuation.specialization.enable (default: false)
+Use specialized semantic tokens for punctuation.
+When enabled, rust-analyzer will emit special token types for punctuation tokens instead
+of the generic punctuation token type.
rust-analyzer.semanticHighlighting.strings.enable (default: true)
+Use semantic tokens for strings.
+In some editors (e.g. vscode) semantic tokens override other highlighting grammars. +By disabling semantic tokens for strings, other grammars can be used to highlight +their contents.
+rust-analyzer.signatureInfo.detail (default: "full")
+Show full signature of the callable. Only shows parameters if disabled.
+rust-analyzer.signatureInfo.documentation.enable (default: true)
+Show documentation.
+rust-analyzer.typing.autoClosingAngleBrackets.enable (default: false)
+Whether to insert closing angle brackets when typing an opening angle bracket of a generic argument list.
+rust-analyzer.workspace.symbol.search.kind (default: "only_types")
+Workspace symbol search kind.
+rust-analyzer.workspace.symbol.search.limit (default: 128)
+Limits the number of items returned from a workspace symbol search (Defaults to 128). +Some clients like vs-code issue new searches on result filtering and don't require all results to be returned in the initial search. +Other clients requires all results upfront and might require a higher limit.
+rust-analyzer.workspace.symbol.search.scope (default: "workspace")
+Workspace symbol search scope.
+Non-Cargo Based Projects
+rust-analyzer does not require Cargo. However, if you use some other
+build system, you’ll have to describe the structure of your project for
+rust-analyzer in the rust-project.json format:
interface JsonProject {
+ /// Path to the sysroot directory.
+ ///
+ /// The sysroot is where rustc looks for the
+ /// crates that are built-in to rust, such as
+ /// std.
+ ///
+ /// https://doc.rust-lang.org/rustc/command-line-arguments.html#--sysroot-override-the-system-root
+ ///
+ /// To see the current value of sysroot, you
+ /// can query rustc:
+ ///
+ /// ```
+ /// $ rustc --print sysroot
+ /// /Users/yourname/.rustup/toolchains/stable-x86_64-apple-darwin
+ /// ```
+ sysroot?: string;
+ /// Path to the directory with *source code* of
+ /// sysroot crates.
+ ///
+ /// By default, this is `lib/rustlib/src/rust/library`
+ /// relative to the sysroot.
+ ///
+ /// It should point to the directory where std,
+ /// core, and friends can be found:
+ ///
+ /// https://github.com/rust-lang/rust/tree/master/library.
+ ///
+ /// If provided, rust-analyzer automatically adds
+ /// dependencies on sysroot crates. Conversely,
+ /// if you omit this path, you can specify sysroot
+ /// dependencies yourself and, for example, have
+ /// several different "sysroots" in one graph of
+ /// crates.
+ sysroot_src?: string;
+ /// The set of crates comprising the current
+ /// project. Must include all transitive
+ /// dependencies as well as sysroot crate (libstd,
+ /// libcore and such).
+ crates: Crate[];
+}
+
+interface Crate {
+ /// Optional crate name used for display purposes,
+ /// without affecting semantics. See the `deps`
+ /// key for semantically-significant crate names.
+ display_name?: string;
+ /// Path to the root module of the crate.
+ root_module: string;
+ /// Edition of the crate.
+ edition: "2015" | "2018" | "2021";
+ /// Dependencies
+ deps: Dep[];
+ /// Should this crate be treated as a member of
+ /// current "workspace".
+ ///
+ /// By default, inferred from the `root_module`
+ /// (members are the crates which reside inside
+ /// the directory opened in the editor).
+ ///
+ /// Set this to `false` for things like standard
+ /// library and 3rd party crates to enable
+ /// performance optimizations (rust-analyzer
+ /// assumes that non-member crates don't change).
+ is_workspace_member?: boolean;
+ /// Optionally specify the (super)set of `.rs`
+ /// files comprising this crate.
+ ///
+ /// By default, rust-analyzer assumes that only
+ /// files under `root_module.parent` can belong
+ /// to a crate. `include_dirs` are included
+ /// recursively, unless a subdirectory is in
+ /// `exclude_dirs`.
+ ///
+ /// Different crates can share the same `source`.
+ ///
+ /// If two crates share an `.rs` file in common,
+ /// they *must* have the same `source`.
+ /// rust-analyzer assumes that files from one
+ /// source can't refer to files in another source.
+ source?: {
+ include_dirs: string[],
+ exclude_dirs: string[],
+ },
+ /// The set of cfgs activated for a given crate, like
+ /// `["unix", "feature=\"foo\"", "feature=\"bar\""]`.
+ cfg: string[];
+ /// Target triple for this Crate.
+ ///
+ /// Used when running `rustc --print cfg`
+ /// to get target-specific cfgs.
+ target?: string;
+ /// Environment variables, used for
+ /// the `env!` macro
+ env: { [key: string]: string; },
+
+ /// Whether the crate is a proc-macro crate.
+ is_proc_macro: boolean;
+ /// For proc-macro crates, path to compiled
+ /// proc-macro (.so file).
+ proc_macro_dylib_path?: string;
+}
+
+interface Dep {
+ /// Index of a crate in the `crates` array.
+ crate: number,
+ /// Name as should appear in the (implicit)
+ /// `extern crate name` declaration.
+ name: string,
+}
+This format is provisional and subject to change. Specifically, the
+roots setup will be different eventually.
There are three ways to feed rust-project.json to rust-analyzer:
-
+
-
+
Place
+rust-project.jsonfile at the root of the project, and +rust-analyzer will discover it.
+ -
+
Specify +
+"rust-analyzer.linkedProjects": [ "path/to/rust-project.json" ]in +the settings (and make sure that your LSP client sends settings as a +part of initialize request).
+ -
+
Specify +
+"rust-analyzer.linkedProjects": [ { "roots": […], "crates": […] }]+inline.
+
Relative paths are interpreted relative to rust-project.json file
+location or (for inline JSON) relative to rootUri.
See https://github.com/rust-analyzer/rust-project.json-example for a +small example.
+You can set the RA_LOG environment variable to rust_analyzer=info to
+inspect how rust-analyzer handles config and project loading.
Note that calls to cargo check are disabled when using
+rust-project.json by default, so compilation errors and warnings will
+no longer be sent to your LSP client. To enable these compilation errors
+you will need to specify explicitly what command rust-analyzer should
+run to perform the checks using the
+rust-analyzer.check.overrideCommand configuration. As an example, the
+following configuration explicitly sets cargo check as the check
+command.
{ "rust-analyzer.check.overrideCommand": ["cargo", "check", "--message-format=json"] }
+check.overrideCommand requires the command specified to output json
+error messages for rust-analyzer to consume. The --message-format=json
+flag does this for cargo check so whichever command you use must also
+output errors in this format. See the Configuration
+section for more information.
Security
+At the moment, rust-analyzer assumes that all code is trusted. Here is a +non-exhaustive list of ways to make rust-analyzer execute arbitrary +code:
+-
+
-
+
proc macros and build scripts are executed by default
+
+ -
+
+.cargo/configcan overriderustcwith an arbitrary executable
+ -
+
+rust-toolchain.tomlcan overriderustcwith an arbitrary +executable
+ -
+
VS Code plugin reads configuration from project directory, and that +can be used to override paths to various executables, like
+rustfmt+orrust-analyzeritself.
+ -
+
rust-analyzer’s syntax trees library uses a lot of
+unsafeand +hasn’t been properly audited for memory safety.
+
Privacy
+The LSP server performs no network access in itself, but runs
+cargo metadata which will update or download the crate registry and
+the source code of the project dependencies. If enabled (the default),
+build scripts and procedural macros can do anything.
The Code extension does not access the network.
+Any other editor plugins are not under the control of the
+rust-analyzer developers. For any privacy concerns, you should check
+with their respective developers.
For rust-analyzer developers, cargo xtask release uses the GitHub
+API to put together the release notes.
Features
+Annotations
+Source: annotations.rs
+Provides user with annotations above items for looking up references or impl blocks +and running/debugging binaries.
+
Auto Import
+Source: auto_import.rs
+Using the auto-import assist it is possible to insert missing imports for unresolved items.
+When inserting an import it will do so in a structured manner by keeping imports grouped,
+separated by a newline in the following order:
-
+
stdandcore
+- External Crates +
- Current Crate, paths prefixed by
crate
+ - Current Module, paths prefixed by
self
+ - Super Module, paths prefixed by
super
+
Example:
+use std::fs::File;
+
+use itertools::Itertools;
+use syntax::ast;
+
+use crate::utils::insert_use;
+
+use self::auto_import;
+
+use super::AssistContext;Import Granularity
+It is possible to configure how use-trees are merged with the imports.granularity.group setting.
+It has the following configurations:
-
+
crate: Merge imports from the same crate into a single use statement. This kind of +nesting is only supported in Rust versions later than 1.24.
+module: Merge imports from the same module into a single use statement.
+item: Don't merge imports at all, creating one import per item.
+preserve: Do not change the granularity of any imports. For auto-import this has the same +effect asitem.
+
In VS Code the configuration for this is rust-analyzer.imports.granularity.group.
Import Prefix
+The style of imports in the same crate is configurable through the imports.prefix setting.
+It has the following configurations:
-
+
crate: This setting will force paths to be always absolute, starting with thecrate+prefix, unless the item is defined outside of the current crate.
+self: This setting will force paths that are relative to the current module to always +start withself. This will result in paths that always start with eithercrate,self, +superor an extern crate identifier.
+plain: This setting does not impose any restrictions in imports.
+
In VS Code the configuration for this is rust-analyzer.imports.prefix.
Completion With Autoimport
+Source: flyimport.rs
+When completing names in the current scope, proposes additional imports from other modules or crates, +if they can be qualified in the scope, and their name contains all symbols from the completion input.
+To be considered applicable, the name must contain all input symbols in the given order, not necessarily adjacent. +If any input symbol is not lowercased, the name must contain all symbols in exact case; otherwise the containing is checked case-insensitively.
+fn main() {
+ pda$0
+}
+# pub mod std { pub mod marker { pub struct PhantomData { } } }
+->
+use std::marker::PhantomData;
+
+fn main() {
+ PhantomData
+}
+# pub mod std { pub mod marker { pub struct PhantomData { } } }
+Also completes associated items, that require trait imports. +If any unresolved and/or partially-qualified path precedes the input, it will be taken into account. +Currently, only the imports with their import path ending with the whole qualifier will be proposed +(no fuzzy matching for qualifier).
+mod foo {
+ pub mod bar {
+ pub struct Item;
+
+ impl Item {
+ pub const TEST_ASSOC: usize = 3;
+ }
+ }
+}
+
+fn main() {
+ bar::Item::TEST_A$0
+}
+->
+use foo::bar;
+
+mod foo {
+ pub mod bar {
+ pub struct Item;
+
+ impl Item {
+ pub const TEST_ASSOC: usize = 3;
+ }
+ }
+}
+
+fn main() {
+ bar::Item::TEST_ASSOC
+}
+NOTE: currently, if an assoc item comes from a trait that's not currently imported, and it also has an unresolved and/or partially-qualified path, +no imports will be proposed.
+Fuzzy search details
+To avoid an excessive amount of the results returned, completion input is checked for inclusion in the names only
+(i.e. in HashMap in the std::collections::HashMap path).
+For the same reasons, avoids searching for any path imports for inputs with their length less than 2 symbols
+(but shows all associated items for any input length).
Import configuration
+It is possible to configure how use-trees are merged with the imports.granularity.group setting.
+Mimics the corresponding behavior of the Auto Import feature.
LSP and performance implications
+The feature is enabled only if the LSP client supports LSP protocol version 3.16+ and reports the additionalTextEdits
+(case-sensitive) resolve client capability in its client capabilities.
+This way the server is able to defer the costly computations, doing them for a selected completion item only.
+For clients with no such support, all edits have to be calculated on the completion request, including the fuzzy search completion ones,
+which might be slow ergo the feature is automatically disabled.
Feature toggle
+The feature can be forcefully turned off in the settings with the rust-analyzer.completion.autoimport.enable flag.
+Note that having this flag set to true does not guarantee that the feature is enabled: your client needs to have the corresponding
+capability enabled.
Debug ItemTree
+Source: view_item_tree.rs
+Displays the ItemTree of the currently open file, for debugging.
+| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: Debug ItemTree |
Expand Macro Recursively
+Source: expand_macro.rs
+Shows the full macro expansion of the macro at current cursor.
+| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: Expand macro recursively |
Expand and Shrink Selection
+Source: extend_selection.rs
+Extends or shrinks the current selection to the encompassing syntactic construct +(expression, statement, item, module, etc). It works with multiple cursors.
+| Editor | Shortcut |
|---|---|
| VS Code | Alt+Shift+→, Alt+Shift+← |
File Structure
+Source: file_structure.rs
+Provides a tree of the symbols defined in the file. Can be used to
+-
+
- fuzzy search symbol in a file (super useful) +
- draw breadcrumbs to describe the context around the cursor +
- draw outline of the file +
| Editor | Shortcut |
|---|---|
| VS Code | Ctrl+Shift+O |
Find All References
+Source: references.rs
+Shows all references of the item at the cursor location
+| Editor | Shortcut |
|---|---|
| VS Code | Shift+Alt+F12 |
Folding
+Source: folding_ranges.rs
+Defines folding regions for curly braced blocks, runs of consecutive use, mod, const or static
+items, and region / endregion comment markers.
Format String Completion
+Source: format_like.rs
+"Result {result} is {2 + 2}" is expanded to the "Result {} is {}", result, 2 + 2.
The following postfix snippets are available:
+-
+
format->format!(...)
+panic->panic!(...)
+println->println!(...)
+log: +**logd->log::debug!(...)+**logt->log::trace!(...)+**logi->log::info!(...)+**logw->log::warn!(...)+**loge->log::error!(...)
+
Go to Declaration
+Source: goto_declaration.rs
+Navigates to the declaration of an identifier.
+This is the same as Go to Definition with the following exceptions:
-
+
- outline modules will navigate to the
mod name;item declaration
+ - trait assoc items will navigate to the assoc item of the trait declaration opposed to the trait impl +
- fields in patterns will navigate to the field declaration of the struct, union or variant +
Go to Definition
+Source: goto_definition.rs
+Navigates to the definition of an identifier.
+For outline modules, this will navigate to the source file of the module.
+| Editor | Shortcut |
|---|---|
| VS Code | F12 |
Go to Implementation
+Source: goto_implementation.rs
+Navigates to the impl blocks of types.
+| Editor | Shortcut |
|---|---|
| VS Code | Ctrl+F12 |
Go to Type Definition
+Source: goto_type_definition.rs
+Navigates to the type of an identifier.
+| Editor | Action Name |
|---|---|
| VS Code | Go to Type Definition |
Highlight Related
+Source: highlight_related.rs
+Highlights constructs related to the thing under the cursor:
+. if on an identifier, highlights all references to that identifier in the current file
+.. additionally, if the identifier is a trait in a where clause, type parameter trait bound or use item, highlights all references to that trait's assoc items in the corresponding scope
+. if on an async or await token, highlights all yield points for that async context . if on a returnorfnkeyword,?character or->return type arrow, highlights all exit points for that context . if on abreak, loop, whileorfortoken, highlights all break points for that loop or block context . if on amoveor|` token that belongs to a closure, highlights all captures of the closure.
Note: ?, | and -> do not currently trigger this behavior in the VSCode editor.
Hover
+Source: hover.rs
+Shows additional information, like the type of an expression or the documentation for a definition when "focusing" code. +Focusing is usually hovering with a mouse, but can also be triggered with a shortcut.
+
Inlay Hints
+Source: inlay_hints.rs
+rust-analyzer shows additional information inline with the source code. +Editors usually render this using read-only virtual text snippets interspersed with code.
+rust-analyzer by default shows hints for
+-
+
- types of local variables +
- names of function arguments +
- types of chained expressions +
Optionally, one can enable additional hints for
+-
+
- return types of closure expressions +
- elided lifetimes +
- compiler inserted reborrows +
Interpret Function
+Source: interpret_function.rs
+| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: Interpret Function |
Join Lines
+Source: join_lines.rs
+Join selected lines into one, smartly fixing up whitespace, trailing commas, and braces.
+See this gif for the cases handled specially by joined lines.
+
| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: Join lines |
Magic Completions
+Source: lib.rs
+In addition to usual reference completion, rust-analyzer provides some ✨magic✨ +completions as well:
+Keywords like if, else while, loop are completed with braces, and cursor
+is placed at the appropriate position. Even though if is easy to type, you
+still want to complete it, to get { } for free! return is inserted with a
+space or ; depending on the return type of the function.
When completing a function call, () are automatically inserted. If a function
+takes arguments, the cursor is positioned inside the parenthesis.
There are postfix completions, which can be triggered by typing something like
+foo().if. The word after . determines postfix completion. Possible variants are:
-
+
expr.if->if expr {}orif let ... {}forOptionorResult
+expr.match->match expr {}
+expr.while->while expr {}orwhile let ... {}forOptionorResult
+expr.ref->&expr
+expr.refm->&mut expr
+expr.let->let $0 = expr;
+expr.letm->let mut $0 = expr;
+expr.not->!expr
+expr.dbg->dbg!(expr)
+expr.dbgr->dbg!(&expr)
+expr.call->(expr)
+
There also snippet completions:
+Expressions
+-
+
pd->eprintln!(" = {:?}", );
+ppd->eprintln!(" = {:#?}", );
+
Items
+-
+
tfn->#[test] fn feature(){}
+tmod->
+
#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_name() {}
+}And the auto import completions, enabled with the rust-analyzer.completion.autoimport.enable setting and the corresponding LSP client capabilities.
+Those are the additional completion options with automatic use import and options from all project importable items,
+fuzzy matched against the completion input.
Matching Brace
+Source: matching_brace.rs
+If the cursor is on any brace (<>(){}[]||) which is a part of a brace-pair,
+moves cursor to the matching brace. It uses the actual parser to determine
+braces, so it won't confuse generics with comparisons.
| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: Find matching brace |
Memory Usage
+Source: apply_change.rs
+Clears rust-analyzer's internal database and prints memory usage statistics.
+| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: Memory Usage (Clears Database) |
Move Item
+Source: move_item.rs
+Move item under cursor or selection up and down.
+| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: Move item up |
| VS Code | rust-analyzer: Move item down |
On Enter
+Source: on_enter.rs
+rust-analyzer can override kbd:[Enter] key to make it smarter:
+-
+
- Enter inside triple-slash comments automatically inserts
///
+ - Enter in the middle or after a trailing space in
//inserts//
+ - Enter inside
//!doc comments automatically inserts//!
+ - Enter after
{indents contents and closing}of single-line block
+
This action needs to be assigned to shortcut explicitly.
+Note that, depending on the other installed extensions, this feature can visibly slow down typing.
+Similarly, if rust-analyzer crashes or stops responding, Enter might not work.
+In that case, you can still press Shift-Enter to insert a newline.
VS Code::
+Add the following to keybindings.json:
{
+ "key": "Enter",
+ "command": "rust-analyzer.onEnter",
+ "when": "editorTextFocus && !suggestWidgetVisible && editorLangId == rust"
+}
+When using the Vim plugin:
+{
+ "key": "Enter",
+ "command": "rust-analyzer.onEnter",
+ "when": "editorTextFocus && !suggestWidgetVisible && editorLangId == rust && vim.mode == 'Insert'"
+}
+
On Typing Assists
+Source: typing.rs
+Some features trigger on typing certain characters:
+-
+
- typing
let =tries to smartly add;if=is followed by an existing expression
+ - typing
=between two expressions adds;when in statement position
+ - typing
=to turn an assignment into an equality comparison removes;when in expression position
+ - typing
.in a chain method call auto-indents
+ - typing
{or(in front of an expression inserts a closing}or)after the expression
+ - typing
{in a use item adds a closing}in the right place
+
VS Code::
+Add the following to settings.json:
"editor.formatOnType": true,
+
+
Open Docs
+Source: doc_links.rs
+Retrieve a links to documentation for the given symbol.
+The simplest way to use this feature is via the context menu. Right-click on +the selected item. The context menu opens. Select Open Docs.
+| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: Open Docs |
Parent Module
+Source: parent_module.rs
+Navigates to the parent module of the current module.
+| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: Locate parent module |
Related Tests
+Source: runnables.rs
+Provides a sneak peek of all tests where the current item is used.
+The simplest way to use this feature is via the context menu. Right-click on +the selected item. The context menu opens. Select Peek Related Tests.
+| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: Peek Related Tests |
Rename
+Source: rename.rs
+Renames the item below the cursor and all of its references
+| Editor | Shortcut |
|---|---|
| VS Code | F2 |
Run
+Source: runnables.rs
+Shows a popup suggesting to run a test/benchmark/binary at the current cursor +location. Super useful for repeatedly running just a single test. Do bind this +to a shortcut!
+| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: Run |
Semantic Syntax Highlighting
+Source: syntax_highlighting.rs
+rust-analyzer highlights the code semantically.
+For example, Bar in foo::Bar might be colored differently depending on whether Bar is an enum or a trait.
+rust-analyzer does not specify colors directly, instead it assigns a tag (like struct) and a set of modifiers (like declaration) to each token.
+It's up to the client to map those to specific colors.
The general rule is that a reference to an entity gets colored the same way as the entity itself.
+We also give special modifier for mut and &mut local variables.
Token Tags
+Rust-analyzer currently emits the following token tags:
+-
+
- For items: +
| attribute | Emitted for attribute macros. |
| enum | Emitted for enums. |
| function | Emitted for free-standing functions. |
| derive | Emitted for derive macros. |
| macro | Emitted for function-like macros. |
| method | Emitted for associated functions, also knowns as methods. |
| namespace | Emitted for modules. |
| struct | Emitted for structs. |
| trait | Emitted for traits. |
| typeAlias | Emitted for type aliases and Self in impls. |
| union | Emitted for unions. |
-
+
- For literals: +
| boolean | Emitted for the boolean literals true and false. |
| character | Emitted for character literals. |
| number | Emitted for numeric literals. |
| string | Emitted for string literals. |
| escapeSequence | Emitted for escaped sequences inside strings like \n. |
| formatSpecifier | Emitted for format specifiers {:?} in format!-like macros. |
-
+
- For operators: +
| operator | Emitted for general operators. |
| arithmetic | Emitted for the arithmetic operators +, -, *, /, +=, -=, *=, /=. |
| bitwise | Emitted for the bitwise operators ` |
| comparison | Emitted for the comparison oerators >, <, ==, >=, <=, !=. |
| logical | Emitted for the logical operatos ` |
-
+
- For punctuation: +
| punctuation | Emitted for general punctuation. |
| attributeBracket | Emitted for attribute invocation brackets, that is the #[ and ] tokens. |
| angle | Emitted for <> angle brackets. |
| brace | Emitted for {} braces. |
| bracket | Emitted for [] brackets. |
| parenthesis | Emitted for () parentheses. |
| colon | Emitted for the : token. |
| comma | Emitted for the , token. |
| dot | Emitted for the . token. |
| semi | Emitted for the ; token. |
| macroBang | Emitted for the ! token in macro calls. |
-
+
+
| builtinAttribute | Emitted for names to builtin attributes in attribute path, the repr in #[repr(u8)] for example. |
| builtinType | Emitted for builtin types like u32, str and f32. |
| comment | Emitted for comments. |
| constParameter | Emitted for const parameters. |
| deriveHelper | Emitted for derive helper attributes. |
| enumMember | Emitted for enum variants. |
| generic | Emitted for generic tokens that have no mapping. |
| keyword | Emitted for keywords. |
| label | Emitted for labels. |
| lifetime | Emitted for lifetimes. |
| parameter | Emitted for non-self function parameters. |
| property | Emitted for struct and union fields. |
| selfKeyword | Emitted for the self function parameter and self path-specifier. |
| selfTypeKeyword | Emitted for the Self type parameter. |
| toolModule | Emitted for tool modules. |
| typeParameter | Emitted for type parameters. |
| unresolvedReference | Emitted for unresolved references, names that rust-analyzer can't find the definition of. |
| variable | Emitted for locals, constants and statics. |
Token Modifiers
+Token modifiers allow to style some elements in the source code more precisely.
+Rust-analyzer currently emits the following token modifiers:
+| async | Emitted for async functions and the async and await keywords. |
| attribute | Emitted for tokens inside attributes. |
| callable | Emitted for locals whose types implements one of the Fn* taits. |
| constant | Emitted for const. |
| consuming | Emitted for locals that are being consumed when use in a fuction call. |
| controlFlow | Emitted for control-flow related tokens, this includes th ? operator. |
| crateRoot | Emitted for crate names, like serde and `crate. |
| declaration | Emitted for names of definitions, like foo in fn foo(){}. |
| defaultLibrary | Emitted for items from built-in crates (std, core, allc, test and proc_macro). |
| documentation | Emitted for documentation comment. |
| injected | Emitted for doc-string injected highlighting like rust sourc blocks in documentation. |
| intraDocLink | Emitted for intra doc links in doc-string. |
| library | Emitted for items that are defined outside of the current crae. |
| macro | Emitted for tokens inside macro call. |
| mutable | Emitted for mutable locals and statics as well as functions tking &mut self. |
| public | Emitted for items that are from the current crate and are `pub. |
| reference | Emitted for locals behind a reference and functions taking self` by reference. |
| static | Emitted for "static" functions, also known as functions that d not take a self param, as well as statics and consts. |
| trait | Emitted for associated trait item. |
| unsafe | Emitted for unsafe operations, like unsafe function calls, as ell as the unsafe token. |
+
Show Dependency Tree
+Source: fetch_crates.rs
+Shows a view tree with all the dependencies of this project
+| Editor | Panel Name |
|---|---|
| VS Code | Rust Dependencies |
Show Syntax Tree
+Source: syntax_tree.rs
+Shows the parse tree of the current file. It exists mostly for debugging +rust-analyzer itself.
+| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: Show Syntax Tree |
Shuffle Crate Graph
+Source: shuffle_crate_graph.rs
+Randomizes all crate IDs in the crate graph, for debugging.
+| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: Shuffle Crate Graph |
Status
+Source: status.rs
+Shows internal statistic about memory usage of rust-analyzer.
+| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: Status |
Structural Search and Replace
+Source: lib.rs
+Search and replace with named wildcards that will match any expression, type, path, pattern or item.
+The syntax for a structural search replace command is <search_pattern> ==>> <replace_pattern>.
+A $<name> placeholder in the search pattern will match any AST node and $<name> will reference it in the replacement.
+Within a macro call, a placeholder will match up until whatever token follows the placeholder.
All paths in both the search pattern and the replacement template must resolve in the context
+in which this command is invoked. Paths in the search pattern will then match the code if they
+resolve to the same item, even if they're written differently. For example if we invoke the
+command in the module foo with a pattern of Bar, then code in the parent module that refers
+to foo::Bar will match.
Paths in the replacement template will be rendered appropriately for the context in which the
+replacement occurs. For example if our replacement template is foo::Bar and we match some
+code in the foo module, we'll insert just Bar.
Inherent method calls should generally be written in UFCS form. e.g. foo::Bar::baz($s, $a) will
+match $s.baz($a), provided the method call baz resolves to the method foo::Bar::baz. When a
+placeholder is the receiver of a method call in the search pattern (e.g. $s.foo()), but not in
+the replacement template (e.g. bar($s)), then *, & and &mut will be added as needed to mirror
+whatever autoderef and autoref was happening implicitly in the matched code.
The scope of the search / replace will be restricted to the current selection if any, otherwise +it will apply to the whole workspace.
+Placeholders may be given constraints by writing them as ${<name>:<constraint1>:<constraint2>...}.
Supported constraints:
+| Constraint | Restricts placeholder |
|---|---|
| kind(literal) | Is a literal (e.g. 42 or "forty two") |
| not(a) | Negates the constraint a |
Available via the command rust-analyzer.ssr.
// Using structural search replace command [foo($a, $b) ==>> ($a).foo($b)]
+
+// BEFORE
+String::from(foo(y + 5, z))
+
+// AFTER
+String::from((y + 5).foo(z))| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: Structural Search Replace |
Also available as an assist, by writing a comment containing the structural +search and replace rule. You will only see the assist if the comment can +be parsed as a valid structural search and replace rule.
+// Place the cursor on the line below to see the assist 💡.
+// foo($a, $b) ==>> ($a).foo($b)User Snippet Completions
+Source: snippet.rs
+rust-analyzer allows the user to define custom (postfix)-snippets that may depend on items to be accessible for the current scope to be applicable.
+A custom snippet can be defined by adding it to the rust-analyzer.completion.snippets.custom object respectively.
{
+ "rust-analyzer.completion.snippets.custom": {
+ "thread spawn": {
+ "prefix": ["spawn", "tspawn"],
+ "body": [
+ "thread::spawn(move || {",
+ "\t$0",
+ "});",
+ ],
+ "description": "Insert a thread::spawn call",
+ "requires": "std::thread",
+ "scope": "expr",
+ }
+ }
+}
+In the example above:
+-
+
-
+
+"thread spawn"is the name of the snippet.
+ -
+
+prefixdefines one or more trigger words that will trigger the snippets completion. +Usingpostfixwill instead create a postfix snippet.
+ -
+
+bodyis one or more lines of content joined via newlines for the final output.
+ -
+
+descriptionis an optional description of the snippet, if unset the snippet name will be used.
+ -
+
+requiresis an optional list of item paths that have to be resolvable in the current crate where the completion is rendered.
+
View Crate Graph
+Source: view_crate_graph.rs
+Renders the currently loaded crate graph as an SVG graphic. Requires the dot tool, which
+is part of graphviz, to be installed.
Only workspace crates are included, no crates.io dependencies or sysroot crates.
+| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: View Crate Graph |
View Hir
+Source: view_hir.rs
+| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: View Hir |
View Memory Layout
+Source: view_memory_layout.rs
+Displays the recursive memory layout of a datatype.
+| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: View Memory Layout |
View Mir
+Source: view_mir.rs
+| Editor | Action Name |
|---|---|
| VS Code | rust-analyzer: View Mir |
Workspace Symbol
+Source: symbol_index.rs
+Uses fuzzy-search to find types, modules and functions by name across your
+project and dependencies. This is the most useful feature, which improves code
+navigation tremendously. It mostly works on top of the built-in LSP
+functionality, however # and * symbols can be used to narrow down the
+search. Specifically,
-
+
Foosearches forFootype in the current workspace
+foo#searches forfoofunction in the current workspace
+Foo*searches forFootype among dependencies, includingstdlib
+foo#*searches forfoofunction among dependencies
+
That is, # switches from "types" to all symbols, * switches from the current
+workspace to dependencies.
Note that filtering does not currently work in VSCode due to the editor never
+sending the special symbols to the language server. Instead, you can configure
+the filtering via the rust-analyzer.workspace.symbol.search.scope and
+rust-analyzer.workspace.symbol.search.kind settings.
| Editor | Shortcut |
|---|---|
| VS Code | Ctrl+T |
Assists
+Assists, or code actions, are small local refactorings, available in a
+particular context. They are usually triggered by a shortcut or by
+clicking a light bulb icon in the editor. Cursor position or selection
+is signified by ┃ character.
add_braces
+Source: add_braces.rs
+Adds braces to lambda and match arm expressions.
+Before
+fn foo(n: i32) -> i32 {
+ match n {
+ 1 =>┃ n + 1,
+ _ => 0
+ }
+}After
+fn foo(n: i32) -> i32 {
+ match n {
+ 1 => {
+ n + 1
+ },
+ _ => 0
+ }
+}add_explicit_type
+Source: add_explicit_type.rs
+Specify type for a let binding.
+Before
+fn main() {
+ let x┃ = 92;
+}After
+fn main() {
+ let x: i32 = 92;
+}add_hash
+Source: raw_string.rs
+Adds a hash to a raw string literal.
+Before
+fn main() {
+ r#"Hello,┃ World!"#;
+}After
+fn main() {
+ r##"Hello, World!"##;
+}add_impl_default_members
+Source: add_missing_impl_members.rs
+Adds scaffold for overriding default impl members.
+Before
+trait Trait {
+ type X;
+ fn foo(&self);
+ fn bar(&self) {}
+}
+
+impl Trait for () {
+ type X = ();
+ fn foo(&self) {}┃
+}After
+trait Trait {
+ type X;
+ fn foo(&self);
+ fn bar(&self) {}
+}
+
+impl Trait for () {
+ type X = ();
+ fn foo(&self) {}
+
+ ┃fn bar(&self) {}
+}add_impl_missing_members
+Source: add_missing_impl_members.rs
+Adds scaffold for required impl members.
+Before
+trait Trait<T> {
+ type X;
+ fn foo(&self) -> T;
+ fn bar(&self) {}
+}
+
+impl Trait<u32> for () {┃
+
+}After
+trait Trait<T> {
+ type X;
+ fn foo(&self) -> T;
+ fn bar(&self) {}
+}
+
+impl Trait<u32> for () {
+ ┃type X;
+
+ fn foo(&self) -> u32 {
+ todo!()
+ }
+}add_label_to_loop
+Source: add_label_to_loop.rs
+Adds a label to a loop.
+Before
+fn main() {
+ loop┃ {
+ break;
+ continue;
+ }
+}After
+fn main() {
+ 'l: loop {
+ break 'l;
+ continue 'l;
+ }
+}add_lifetime_to_type
+Source: add_lifetime_to_type.rs
+Adds a new lifetime to a struct, enum or union.
+Before
+struct Point {
+ x: &┃u32,
+ y: u32,
+}After
+struct Point<'a> {
+ x: &'a u32,
+ y: u32,
+}add_missing_match_arms
+Source: add_missing_match_arms.rs
+Adds missing clauses to a match expression.
Before
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+ match action {
+ ┃
+ }
+}After
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+ match action {
+ ┃Action::Move { distance } => todo!(),
+ Action::Stop => todo!(),
+ }
+}add_return_type
+Source: add_return_type.rs
+Adds the return type to a function or closure inferred from its tail expression if it doesn't have a return +type specified. This assists is useable in a functions or closures tail expression or return type position.
+Before
+fn foo() { 4┃2i32 }After
+fn foo() -> i32 { 42i32 }add_turbo_fish
+Source: add_turbo_fish.rs
+Adds ::<_> to a call of a generic method or function.
Before
+fn make<T>() -> T { todo!() }
+fn main() {
+ let x = make┃();
+}After
+fn make<T>() -> T { todo!() }
+fn main() {
+ let x = make::<${0:_}>();
+}apply_demorgan
+Source: apply_demorgan.rs
+Apply https://en.wikipedia.org/wiki/De_Morgan%27s_laws[De Morgan's law].
+This transforms expressions of the form !l || !r into !(l && r).
+This also works with &&. This assist can only be applied with the cursor
+on either || or &&.
Before
+fn main() {
+ if x != 4 ||┃ y < 3.14 {}
+}After
+fn main() {
+ if !(x == 4 && y >= 3.14) {}
+}apply_demorgan_iterator
+Source: apply_demorgan.rs
+Apply https://en.wikipedia.org/wiki/De_Morgan%27s_laws[De Morgan's law] to
+Iterator::all and Iterator::any.
This transforms expressions of the form !iter.any(|x| predicate(x)) into
+iter.all(|x| !predicate(x)) and vice versa. This also works the other way for
+Iterator::all into Iterator::any.
Before
+fn main() {
+ let arr = [1, 2, 3];
+ if !arr.into_iter().┃any(|num| num == 4) {
+ println!("foo");
+ }
+}After
+fn main() {
+ let arr = [1, 2, 3];
+ if arr.into_iter().all(|num| num != 4) {
+ println!("foo");
+ }
+}auto_import
+Source: auto_import.rs
+If the name is unresolved, provides all possible imports for it.
+Before
+fn main() {
+ let map = HashMap┃::new();
+}After
+use std::collections::HashMap;
+
+fn main() {
+ let map = HashMap::new();
+}bind_unused_param
+Source: bind_unused_param.rs
+Binds unused function parameter to an underscore.
+Before
+fn some_function(x: i32┃) {}After
+fn some_function(x: i32) {
+ let _ = x;
+}bool_to_enum
+Source: bool_to_enum.rs
+This converts boolean local variables, fields, constants, and statics into a new
+enum with two variants Bool::True and Bool::False, as well as replacing
+all assignments with the variants and replacing all usages with == Bool::True or
+== Bool::False.
Before
+fn main() {
+ let ┃bool = true;
+
+ if bool {
+ println!("foo");
+ }
+}After
+#[derive(PartialEq, Eq)]
+enum Bool { True, False }
+
+fn main() {
+ let bool = Bool::True;
+
+ if bool == Bool::True {
+ println!("foo");
+ }
+}change_visibility
+Source: change_visibility.rs
+Adds or changes existing visibility specifier.
+Before
+┃fn frobnicate() {}After
+pub(crate) fn frobnicate() {}convert_bool_then_to_if
+Source: convert_bool_then.rs
+Converts a bool::then method call to an equivalent if expression.
Before
+fn main() {
+ (0 == 0).then┃(|| val)
+}After
+fn main() {
+ if 0 == 0 {
+ Some(val)
+ } else {
+ None
+ }
+}convert_for_loop_with_for_each
+Source: convert_iter_for_each_to_for.rs
+Converts a for loop into a for_each loop on the Iterator.
+Before
+fn main() {
+ let x = vec![1, 2, 3];
+ for┃ v in x {
+ let y = v * 2;
+ }
+}After
+fn main() {
+ let x = vec![1, 2, 3];
+ x.into_iter().for_each(|v| {
+ let y = v * 2;
+ });
+}convert_if_to_bool_then
+Source: convert_bool_then.rs
+Converts an if expression into a corresponding bool::then call.
Before
+fn main() {
+ if┃ cond {
+ Some(val)
+ } else {
+ None
+ }
+}After
+fn main() {
+ cond.then(|| val)
+}convert_integer_literal
+Source: convert_integer_literal.rs
+Converts the base of integer literals to other bases.
+Before
+const _: i32 = 10┃;After
+const _: i32 = 0b1010;convert_into_to_from
+Source: convert_into_to_from.rs
+Converts an Into impl to an equivalent From impl.
+Before
+impl ┃Into<Thing> for usize {
+ fn into(self) -> Thing {
+ Thing {
+ b: self.to_string(),
+ a: self
+ }
+ }
+}After
+impl From<usize> for Thing {
+ fn from(val: usize) -> Self {
+ Thing {
+ b: val.to_string(),
+ a: val
+ }
+ }
+}convert_iter_for_each_to_for
+Source: convert_iter_for_each_to_for.rs
+Converts an Iterator::for_each function into a for loop.
+Before
+fn main() {
+ let iter = iter::repeat((9, 2));
+ iter.for_each┃(|(x, y)| {
+ println!("x: {}, y: {}", x, y);
+ });
+}After
+fn main() {
+ let iter = iter::repeat((9, 2));
+ for (x, y) in iter {
+ println!("x: {}, y: {}", x, y);
+ }
+}convert_let_else_to_match
+Source: convert_let_else_to_match.rs
+Converts let-else statement to let statement and match expression.
+Before
+fn main() {
+ let Ok(mut x) = f() else┃ { return };
+}After
+fn main() {
+ let mut x = match f() {
+ Ok(x) => x,
+ _ => return,
+ };
+}convert_match_to_let_else
+Source: convert_match_to_let_else.rs
+Converts let statement with match initializer to let-else statement.
+Before
+fn foo(opt: Option<()>) {
+ let val┃ = match opt {
+ Some(it) => it,
+ None => return,
+ };
+}After
+fn foo(opt: Option<()>) {
+ let Some(val) = opt else { return };
+}convert_named_struct_to_tuple_struct
+Source: convert_named_struct_to_tuple_struct.rs
+Converts struct with named fields to tuple struct, and analogously for enum variants with named +fields.
+Before
+struct Point┃ { x: f32, y: f32 }
+
+impl Point {
+ pub fn new(x: f32, y: f32) -> Self {
+ Point { x, y }
+ }
+
+ pub fn x(&self) -> f32 {
+ self.x
+ }
+
+ pub fn y(&self) -> f32 {
+ self.y
+ }
+}After
+struct Point(f32, f32);
+
+impl Point {
+ pub fn new(x: f32, y: f32) -> Self {
+ Point(x, y)
+ }
+
+ pub fn x(&self) -> f32 {
+ self.0
+ }
+
+ pub fn y(&self) -> f32 {
+ self.1
+ }
+}convert_nested_function_to_closure
+Source: convert_nested_function_to_closure.rs
+Converts a function that is defined within the body of another function into a closure.
+Before
+fn main() {
+ fn fo┃o(label: &str, number: u64) {
+ println!("{}: {}", label, number);
+ }
+
+ foo("Bar", 100);
+}After
+fn main() {
+ let foo = |label: &str, number: u64| {
+ println!("{}: {}", label, number);
+ };
+
+ foo("Bar", 100);
+}convert_to_guarded_return
+Source: convert_to_guarded_return.rs
+Replace a large conditional with a guarded return.
+Before
+fn main() {
+ ┃if cond {
+ foo();
+ bar();
+ }
+}After
+fn main() {
+ if !cond {
+ return;
+ }
+ foo();
+ bar();
+}convert_tuple_return_type_to_struct
+Source: convert_tuple_return_type_to_struct.rs
+This converts the return type of a function from a tuple type +into a tuple struct and updates the body accordingly.
+Before
+fn bar() {
+ let (a, b, c) = foo();
+}
+
+fn foo() -> (┃u32, u32, u32) {
+ (1, 2, 3)
+}After
+fn bar() {
+ let FooResult(a, b, c) = foo();
+}
+
+struct FooResult(u32, u32, u32);
+
+fn foo() -> FooResult {
+ FooResult(1, 2, 3)
+}convert_tuple_struct_to_named_struct
+Source: convert_tuple_struct_to_named_struct.rs
+Converts tuple struct to struct with named fields, and analogously for tuple enum variants.
+Before
+struct Point┃(f32, f32);
+
+impl Point {
+ pub fn new(x: f32, y: f32) -> Self {
+ Point(x, y)
+ }
+
+ pub fn x(&self) -> f32 {
+ self.0
+ }
+
+ pub fn y(&self) -> f32 {
+ self.1
+ }
+}After
+struct Point { field1: f32, field2: f32 }
+
+impl Point {
+ pub fn new(x: f32, y: f32) -> Self {
+ Point { field1: x, field2: y }
+ }
+
+ pub fn x(&self) -> f32 {
+ self.field1
+ }
+
+ pub fn y(&self) -> f32 {
+ self.field2
+ }
+}convert_two_arm_bool_match_to_matches_macro
+Source: convert_two_arm_bool_match_to_matches_macro.rs
+Convert 2-arm match that evaluates to a boolean into the equivalent matches! invocation.
+Before
+fn main() {
+ match scrutinee┃ {
+ Some(val) if val.cond() => true,
+ _ => false,
+ }
+}After
+fn main() {
+ matches!(scrutinee, Some(val) if val.cond())
+}convert_while_to_loop
+Source: convert_while_to_loop.rs
+Replace a while with a loop.
+Before
+fn main() {
+ ┃while cond {
+ foo();
+ }
+}After
+fn main() {
+ loop {
+ if !cond {
+ break;
+ }
+ foo();
+ }
+}destructure_tuple_binding
+Source: destructure_tuple_binding.rs
+Destructures a tuple binding in place.
+Before
+fn main() {
+ let ┃t = (1,2);
+ let v = t.0;
+}After
+fn main() {
+ let (┃_0, _1) = (1,2);
+ let v = _0;
+}desugar_doc_comment
+Source: desugar_doc_comment.rs
+Desugars doc-comments to the attribute form.
+Before
+/// Multi-line┃
+/// commentAfter
+#[doc = r"Multi-line
+comment"]expand_glob_import
+Source: expand_glob_import.rs
+Expands glob imports.
+Before
+mod foo {
+ pub struct Bar;
+ pub struct Baz;
+}
+
+use foo::*┃;
+
+fn qux(bar: Bar, baz: Baz) {}After
+mod foo {
+ pub struct Bar;
+ pub struct Baz;
+}
+
+use foo::{Bar, Baz};
+
+fn qux(bar: Bar, baz: Baz) {}extract_expressions_from_format_string
+Source: extract_expressions_from_format_string.rs
+Move an expression out of a format string.
+Before
+fn main() {
+ print!("{var} {x + 1}┃");
+}After
+fn main() {
+ print!("{var} {}"┃, x + 1);
+}extract_function
+Source: extract_function.rs
+Extracts selected statements and comments into new function.
+Before
+fn main() {
+ let n = 1;
+ ┃let m = n + 2;
+ // calculate
+ let k = m + n;┃
+ let g = 3;
+}After
+fn main() {
+ let n = 1;
+ fun_name(n);
+ let g = 3;
+}
+
+fn ┃fun_name(n: i32) {
+ let m = n + 2;
+ // calculate
+ let k = m + n;
+}extract_module
+Source: extract_module.rs
+Extracts a selected region as separate module. All the references, visibility and imports are +resolved.
+Before
+┃fn foo(name: i32) -> i32 {
+ name + 1
+}┃
+
+fn bar(name: i32) -> i32 {
+ name + 2
+}After
+mod modname {
+ pub(crate) fn foo(name: i32) -> i32 {
+ name + 1
+ }
+}
+
+fn bar(name: i32) -> i32 {
+ name + 2
+}extract_struct_from_enum_variant
+Source: extract_struct_from_enum_variant.rs
+Extracts a struct from enum variant.
+Before
+enum A { ┃One(u32, u32) }After
+struct One(u32, u32);
+
+enum A { One(One) }extract_type_alias
+Source: extract_type_alias.rs
+Extracts the selected type as a type alias.
+Before
+struct S {
+ field: ┃(u8, u8, u8)┃,
+}After
+type ┃Type = (u8, u8, u8);
+
+struct S {
+ field: Type,
+}extract_variable
+Source: extract_variable.rs
+Extracts subexpression into a variable.
+Before
+fn main() {
+ ┃(1 + 2)┃ * 4;
+}After
+fn main() {
+ let ┃var_name = (1 + 2);
+ var_name * 4;
+}fix_visibility
+Source: fix_visibility.rs
+Makes inaccessible item public.
+Before
+mod m {
+ fn frobnicate() {}
+}
+fn main() {
+ m::frobnicate┃();
+}After
+mod m {
+ ┃pub(crate) fn frobnicate() {}
+}
+fn main() {
+ m::frobnicate();
+}flip_binexpr
+Source: flip_binexpr.rs
+Flips operands of a binary expression.
+Before
+fn main() {
+ let _ = 90 +┃ 2;
+}After
+fn main() {
+ let _ = 2 + 90;
+}flip_comma
+Source: flip_comma.rs
+Flips two comma-separated items.
+Before
+fn main() {
+ ((1, 2),┃ (3, 4));
+}After
+fn main() {
+ ((3, 4), (1, 2));
+}flip_trait_bound
+Source: flip_trait_bound.rs
+Flips two trait bounds.
+Before
+fn foo<T: Clone +┃ Copy>() { }After
+fn foo<T: Copy + Clone>() { }generate_constant
+Source: generate_constant.rs
+Generate a named constant.
+Before
+struct S { i: usize }
+impl S { pub fn new(n: usize) {} }
+fn main() {
+ let v = S::new(CAPA┃CITY);
+}After
+struct S { i: usize }
+impl S { pub fn new(n: usize) {} }
+fn main() {
+ const CAPACITY: usize = ┃;
+ let v = S::new(CAPACITY);
+}generate_default_from_enum_variant
+Source: generate_default_from_enum_variant.rs
+Adds a Default impl for an enum using a variant.
+Before
+enum Version {
+ Undefined,
+ Minor┃,
+ Major,
+}After
+enum Version {
+ Undefined,
+ Minor,
+ Major,
+}
+
+impl Default for Version {
+ fn default() -> Self {
+ Self::Minor
+ }
+}generate_default_from_new
+Source: generate_default_from_new.rs
+Generates default implementation from new method.
+Before
+struct Example { _inner: () }
+
+impl Example {
+ pub fn n┃ew() -> Self {
+ Self { _inner: () }
+ }
+}After
+struct Example { _inner: () }
+
+impl Example {
+ pub fn new() -> Self {
+ Self { _inner: () }
+ }
+}
+
+impl Default for Example {
+ fn default() -> Self {
+ Self::new()
+ }
+}generate_delegate_methods
+Source: generate_delegate_methods.rs
+Generate delegate methods.
+Before
+struct Age(u8);
+impl Age {
+ fn age(&self) -> u8 {
+ self.0
+ }
+}
+
+struct Person {
+ ag┃e: Age,
+}After
+struct Age(u8);
+impl Age {
+ fn age(&self) -> u8 {
+ self.0
+ }
+}
+
+struct Person {
+ age: Age,
+}
+
+impl Person {
+ ┃fn age(&self) -> u8 {
+ self.age.age()
+ }
+}generate_delegate_trait
+Source: generate_delegate_trait.rs
+Generate delegate trait implementation for StructFields.
Before
+trait SomeTrait {
+ type T;
+ fn fn_(arg: u32) -> u32;
+ fn method_(&mut self) -> bool;
+}
+struct A;
+impl SomeTrait for A {
+ type T = u32;
+
+ fn fn_(arg: u32) -> u32 {
+ 42
+ }
+
+ fn method_(&mut self) -> bool {
+ false
+ }
+}
+struct B {
+ a┃: A,
+}After
+trait SomeTrait {
+ type T;
+ fn fn_(arg: u32) -> u32;
+ fn method_(&mut self) -> bool;
+}
+struct A;
+impl SomeTrait for A {
+ type T = u32;
+
+ fn fn_(arg: u32) -> u32 {
+ 42
+ }
+
+ fn method_(&mut self) -> bool {
+ false
+ }
+}
+struct B {
+ a: A,
+}
+
+impl SomeTrait for B {
+ type T = <A as SomeTrait>::T;
+
+ fn fn_(arg: u32) -> u32 {
+ <A as SomeTrait>::fn_(arg)
+ }
+
+ fn method_(&mut self) -> bool {
+ <A as SomeTrait>::method_( &mut self.a )
+ }
+}generate_deref
+Source: generate_deref.rs
+Generate Deref impl using the given struct field.
Before
+struct A;
+struct B {
+ ┃a: A
+}After
+struct A;
+struct B {
+ a: A
+}
+
+impl core::ops::Deref for B {
+ type Target = A;
+
+ fn deref(&self) -> &Self::Target {
+ &self.a
+ }
+}generate_derive
+Source: generate_derive.rs
+Adds a new #[derive()] clause to a struct or enum.
Before
+struct Point {
+ x: u32,
+ y: u32,┃
+}After
+#[derive(┃)]
+struct Point {
+ x: u32,
+ y: u32,
+}generate_doc_example
+Source: generate_documentation_template.rs
+Generates a rustdoc example when editing an item's documentation.
+Before
+/// Adds two numbers.┃
+pub fn add(a: i32, b: i32) -> i32 { a + b }After
+/// Adds two numbers.
+///
+/// # Examples
+///
+/// ```
+/// use test::add;
+///
+/// assert_eq!(add(a, b), );
+/// ```
+pub fn add(a: i32, b: i32) -> i32 { a + b }generate_documentation_template
+Source: generate_documentation_template.rs
+Adds a documentation template above a function definition / declaration.
+Before
+pub struct S;
+impl S {
+ pub unsafe fn set_len┃(&mut self, len: usize) -> Result<(), std::io::Error> {
+ /* ... */
+ }
+}After
+pub struct S;
+impl S {
+ /// Sets the length of this [`S`].
+ ///
+ /// # Errors
+ ///
+ /// This function will return an error if .
+ ///
+ /// # Safety
+ ///
+ /// .
+ pub unsafe fn set_len(&mut self, len: usize) -> Result<(), std::io::Error> {
+ /* ... */
+ }
+}generate_enum_as_method
+Source: generate_enum_projection_method.rs
+Generate an as_ method for this enum variant.
Before
+enum Value {
+ Number(i32),
+ Text(String)┃,
+}After
+enum Value {
+ Number(i32),
+ Text(String),
+}
+
+impl Value {
+ fn as_text(&self) -> Option<&String> {
+ if let Self::Text(v) = self {
+ Some(v)
+ } else {
+ None
+ }
+ }
+}generate_enum_is_method
+Source: generate_enum_is_method.rs
+Generate an is_ method for this enum variant.
Before
+enum Version {
+ Undefined,
+ Minor┃,
+ Major,
+}After
+enum Version {
+ Undefined,
+ Minor,
+ Major,
+}
+
+impl Version {
+ /// Returns `true` if the version is [`Minor`].
+ ///
+ /// [`Minor`]: Version::Minor
+ #[must_use]
+ fn is_minor(&self) -> bool {
+ matches!(self, Self::Minor)
+ }
+}generate_enum_try_into_method
+Source: generate_enum_projection_method.rs
+Generate a try_into_ method for this enum variant.
Before
+enum Value {
+ Number(i32),
+ Text(String)┃,
+}After
+enum Value {
+ Number(i32),
+ Text(String),
+}
+
+impl Value {
+ fn try_into_text(self) -> Result<String, Self> {
+ if let Self::Text(v) = self {
+ Ok(v)
+ } else {
+ Err(self)
+ }
+ }
+}generate_enum_variant
+Source: generate_enum_variant.rs
+Adds a variant to an enum.
+Before
+enum Countries {
+ Ghana,
+}
+
+fn main() {
+ let country = Countries::Lesotho┃;
+}After
+enum Countries {
+ Ghana,
+ Lesotho,
+}
+
+fn main() {
+ let country = Countries::Lesotho;
+}generate_from_impl_for_enum
+Source: generate_from_impl_for_enum.rs
+Adds a From impl for this enum variant with one tuple field.
+Before
+enum A { ┃One(u32) }After
+enum A { One(u32) }
+
+impl From<u32> for A {
+ fn from(v: u32) -> Self {
+ Self::One(v)
+ }
+}generate_function
+Source: generate_function.rs
+Adds a stub function with a signature matching the function under the cursor.
+Before
+struct Baz;
+fn baz() -> Baz { Baz }
+fn foo() {
+ bar┃("", baz());
+}
+After
+struct Baz;
+fn baz() -> Baz { Baz }
+fn foo() {
+ bar("", baz());
+}
+
+fn bar(arg: &str, baz: Baz) ${0:-> _} {
+ todo!()
+}
+generate_getter
+Source: generate_getter_or_setter.rs
+Generate a getter method.
+Before
+struct Person {
+ nam┃e: String,
+}After
+struct Person {
+ name: String,
+}
+
+impl Person {
+ fn ┃name(&self) -> &str {
+ self.name.as_ref()
+ }
+}generate_getter_mut
+Source: generate_getter_or_setter.rs
+Generate a mut getter method.
+Before
+struct Person {
+ nam┃e: String,
+}After
+struct Person {
+ name: String,
+}
+
+impl Person {
+ fn ┃name_mut(&mut self) -> &mut String {
+ &mut self.name
+ }
+}generate_impl
+Source: generate_impl.rs
+Adds a new inherent impl for a type.
+Before
+struct Ctx┃<T: Clone> {
+ data: T,
+}After
+struct Ctx<T: Clone> {
+ data: T,
+}
+
+impl<T: Clone> Ctx<T> {
+ ┃
+}generate_is_empty_from_len
+Source: generate_is_empty_from_len.rs
+Generates is_empty implementation from the len method.
+Before
+struct MyStruct { data: Vec<String> }
+
+impl MyStruct {
+ #[must_use]
+ p┃ub fn len(&self) -> usize {
+ self.data.len()
+ }
+}After
+struct MyStruct { data: Vec<String> }
+
+impl MyStruct {
+ #[must_use]
+ pub fn len(&self) -> usize {
+ self.data.len()
+ }
+
+ #[must_use]
+ pub fn is_empty(&self) -> bool {
+ self.len() == 0
+ }
+}generate_new
+Source: generate_new.rs
+Adds a fn new for a type.
Before
+struct Ctx<T: Clone> {
+ data: T,┃
+}After
+struct Ctx<T: Clone> {
+ data: T,
+}
+
+impl<T: Clone> Ctx<T> {
+ fn ┃new(data: T) -> Self { Self { data } }
+}generate_setter
+Source: generate_getter_or_setter.rs
+Generate a setter method.
+Before
+struct Person {
+ nam┃e: String,
+}After
+struct Person {
+ name: String,
+}
+
+impl Person {
+ fn ┃set_name(&mut self, name: String) {
+ self.name = name;
+ }
+}generate_trait_from_impl
+Source: generate_trait_from_impl.rs
+Generate trait for an already defined inherent impl and convert impl to a trait impl.
+Before
+struct Foo<const N: usize>([i32; N]);
+
+macro_rules! const_maker {
+ ($t:ty, $v:tt) => {
+ const CONST: $t = $v;
+ };
+}
+
+impl<const N: usize> Fo┃o<N> {
+ // Used as an associated constant.
+ const CONST_ASSOC: usize = N * 4;
+
+ fn create() -> Option<()> {
+ Some(())
+ }
+
+ const_maker! {i32, 7}
+}After
+struct Foo<const N: usize>([i32; N]);
+
+macro_rules! const_maker {
+ ($t:ty, $v:tt) => {
+ const CONST: $t = $v;
+ };
+}
+
+trait ${0:TraitName}<const N: usize> {
+ // Used as an associated constant.
+ const CONST_ASSOC: usize = N * 4;
+
+ fn create() -> Option<()>;
+
+ const_maker! {i32, 7}
+}
+
+impl<const N: usize> ${0:TraitName}<N> for Foo<N> {
+ // Used as an associated constant.
+ const CONST_ASSOC: usize = N * 4;
+
+ fn create() -> Option<()> {
+ Some(())
+ }
+
+ const_maker! {i32, 7}
+}generate_trait_impl
+Source: generate_impl.rs
+Adds a new trait impl for a type.
+Before
+struct ┃Ctx<T: Clone> {
+ data: T,
+}After
+struct Ctx<T: Clone> {
+ data: T,
+}
+
+impl<T: Clone> ┃ for Ctx<T> {
+
+}inline_call
+Source: inline_call.rs
+Inlines a function or method body creating a let statement per parameter unless the parameter
+can be inlined. The parameter will be inlined either if it the supplied argument is a simple local
+or if the parameter is only accessed inside the function body once.
Before
+fn foo(name: Option<&str>) {
+ let name = name.unwrap┃();
+}After
+fn foo(name: Option<&str>) {
+ let name = match name {
+ Some(val) => val,
+ None => panic!("called `Option::unwrap()` on a `None` value"),
+ };
+}inline_const_as_literal
+Source: inline_const_as_literal.rs
+Evaluate and inline const variable as literal.
+Before
+const STRING: &str = "Hello, World!";
+
+fn something() -> &'static str {
+ STRING┃
+}After
+const STRING: &str = "Hello, World!";
+
+fn something() -> &'static str {
+ "Hello, World!"
+}inline_into_callers
+Source: inline_call.rs
+Inline a function or method body into all of its callers where possible, creating a let statement per parameter
+unless the parameter can be inlined. The parameter will be inlined either if it the supplied argument is a simple local
+or if the parameter is only accessed inside the function body once.
+If all calls can be inlined the function will be removed.
Before
+fn print(_: &str) {}
+fn foo┃(word: &str) {
+ if !word.is_empty() {
+ print(word);
+ }
+}
+fn bar() {
+ foo("안녕하세요");
+ foo("여러분");
+}After
+fn print(_: &str) {}
+
+fn bar() {
+ {
+ let word = "안녕하세요";
+ if !word.is_empty() {
+ print(word);
+ }
+ };
+ {
+ let word = "여러분";
+ if !word.is_empty() {
+ print(word);
+ }
+ };
+}inline_local_variable
+Source: inline_local_variable.rs
+Inlines a local variable.
+Before
+fn main() {
+ let x┃ = 1 + 2;
+ x * 4;
+}After
+fn main() {
+ (1 + 2) * 4;
+}inline_macro
+Source: inline_macro.rs
+Takes a macro and inlines it one step.
+Before
+macro_rules! num {
+ (+$($t:tt)+) => (1 + num!($($t )+));
+ (-$($t:tt)+) => (-1 + num!($($t )+));
+ (+) => (1);
+ (-) => (-1);
+}
+
+fn main() {
+ let number = num┃!(+ + + - + +);
+ println!("{number}");
+}After
+macro_rules! num {
+ (+$($t:tt)+) => (1 + num!($($t )+));
+ (-$($t:tt)+) => (-1 + num!($($t )+));
+ (+) => (1);
+ (-) => (-1);
+}
+
+fn main() {
+ let number = 1+num!(+ + - + +);
+ println!("{number}");
+}inline_type_alias
+Source: inline_type_alias.rs
+Replace a type alias with its concrete type.
+Before
+type A<T = u32> = Vec<T>;
+
+fn main() {
+ let a: ┃A;
+}After
+type A<T = u32> = Vec<T>;
+
+fn main() {
+ let a: Vec<u32>;
+}inline_type_alias_uses
+Source: inline_type_alias.rs
+Inline a type alias into all of its uses where possible.
+Before
+type ┃A = i32;
+fn id(x: A) -> A {
+ x
+};
+fn foo() {
+ let _: A = 3;
+}After
+
+fn id(x: i32) -> i32 {
+ x
+};
+fn foo() {
+ let _: i32 = 3;
+}into_to_qualified_from
+Source: into_to_qualified_from.rs
+Convert an into method call to a fully qualified from call.
Before
+//- minicore: from
+struct B;
+impl From<i32> for B {
+ fn from(a: i32) -> Self {
+ B
+ }
+}
+
+fn main() -> () {
+ let a = 3;
+ let b: B = a.in┃to();
+}After
+struct B;
+impl From<i32> for B {
+ fn from(a: i32) -> Self {
+ B
+ }
+}
+
+fn main() -> () {
+ let a = 3;
+ let b: B = B::from(a);
+}introduce_named_generic
+Source: introduce_named_generic.rs
+Replaces impl Trait function argument with the named generic.
Before
+fn foo(bar: ┃impl Bar) {}After
+fn foo<┃B: Bar>(bar: B) {}introduce_named_lifetime
+Source: introduce_named_lifetime.rs
+Change an anonymous lifetime to a named lifetime.
+Before
+impl Cursor<'_┃> {
+ fn node(self) -> &SyntaxNode {
+ match self {
+ Cursor::Replace(node) | Cursor::Before(node) => node,
+ }
+ }
+}After
+impl<'a> Cursor<'a> {
+ fn node(self) -> &SyntaxNode {
+ match self {
+ Cursor::Replace(node) | Cursor::Before(node) => node,
+ }
+ }
+}invert_if
+Source: invert_if.rs
+This transforms if expressions of the form if !x {A} else {B} into if x {B} else {A}
+This also works with !=. This assist can only be applied with the cursor on if.
Before
+fn main() {
+ if┃ !y { A } else { B }
+}After
+fn main() {
+ if y { B } else { A }
+}line_to_block
+Source: convert_comment_block.rs
+Converts comments between block and single-line form.
+Before
+ // Multi-line┃
+ // commentAfter
+ /*
+ Multi-line
+ comment
+ */make_raw_string
+Source: raw_string.rs
+Adds r# to a plain string literal.
Before
+fn main() {
+ "Hello,┃ World!";
+}After
+fn main() {
+ r#"Hello, World!"#;
+}make_usual_string
+Source: raw_string.rs
+Turns a raw string into a plain string.
+Before
+fn main() {
+ r#"Hello,┃ "World!""#;
+}After
+fn main() {
+ "Hello, \"World!\"";
+}merge_imports
+Source: merge_imports.rs
+Merges two imports with a common prefix.
+Before
+use std::┃fmt::Formatter;
+use std::io;After
+use std::{fmt::Formatter, io};merge_match_arms
+Source: merge_match_arms.rs
+Merges the current match arm with the following if their bodies are identical.
+Before
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+ match action {
+ ┃Action::Move(..) => foo(),
+ Action::Stop => foo(),
+ }
+}After
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+ match action {
+ Action::Move(..) | Action::Stop => foo(),
+ }
+}move_arm_cond_to_match_guard
+Source: move_guard.rs
+Moves if expression from match arm body into a guard.
+Before
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+ match action {
+ Action::Move { distance } => ┃if distance > 10 { foo() },
+ _ => (),
+ }
+}After
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+ match action {
+ Action::Move { distance } if distance > 10 => foo(),
+ _ => (),
+ }
+}move_bounds_to_where_clause
+Source: move_bounds.rs
+Moves inline type bounds to a where clause.
+Before
+fn apply<T, U, ┃F: FnOnce(T) -> U>(f: F, x: T) -> U {
+ f(x)
+}After
+fn apply<T, U, F>(f: F, x: T) -> U where F: FnOnce(T) -> U {
+ f(x)
+}move_const_to_impl
+Source: move_const_to_impl.rs
+Move a local constant item in a method to impl's associated constant. All the references will be
+qualified with Self::.
Before
+struct S;
+impl S {
+ fn foo() -> usize {
+ /// The answer.
+ const C┃: usize = 42;
+
+ C * C
+ }
+}After
+struct S;
+impl S {
+ /// The answer.
+ const C: usize = 42;
+
+ fn foo() -> usize {
+ Self::C * Self::C
+ }
+}move_from_mod_rs
+Source: move_from_mod_rs.rs
+Moves xxx/mod.rs to xxx.rs.
+Before
+//- /main.rs
+mod a;
+//- /a/mod.rs
+┃fn t() {}┃After
+fn t() {}move_guard_to_arm_body
+Source: move_guard.rs
+Moves match guard into match arm body.
+Before
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+ match action {
+ Action::Move { distance } ┃if distance > 10 => foo(),
+ _ => (),
+ }
+}After
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+ match action {
+ Action::Move { distance } => if distance > 10 {
+ foo()
+ },
+ _ => (),
+ }
+}move_module_to_file
+Source: move_module_to_file.rs
+Moves inline module's contents to a separate file.
+Before
+mod ┃foo {
+ fn t() {}
+}After
+mod foo;move_to_mod_rs
+Source: move_to_mod_rs.rs
+Moves xxx.rs to xxx/mod.rs.
+Before
+//- /main.rs
+mod a;
+//- /a.rs
+┃fn t() {}┃After
+fn t() {}promote_local_to_const
+Source: promote_local_to_const.rs
+Promotes a local variable to a const item changing its name to a SCREAMING_SNAKE_CASE variant
+if the local uses no non-const expressions.
Before
+fn main() {
+ let foo┃ = true;
+
+ if foo {
+ println!("It's true");
+ } else {
+ println!("It's false");
+ }
+}After
+fn main() {
+ const ┃FOO: bool = true;
+
+ if FOO {
+ println!("It's true");
+ } else {
+ println!("It's false");
+ }
+}pull_assignment_up
+Source: pull_assignment_up.rs
+Extracts variable assignment to outside an if or match statement.
+Before
+fn main() {
+ let mut foo = 6;
+
+ if true {
+ ┃foo = 5;
+ } else {
+ foo = 4;
+ }
+}After
+fn main() {
+ let mut foo = 6;
+
+ foo = if true {
+ 5
+ } else {
+ 4
+ };
+}qualify_method_call
+Source: qualify_method_call.rs
+Replaces the method call with a qualified function call.
+Before
+struct Foo;
+impl Foo {
+ fn foo(&self) {}
+}
+fn main() {
+ let foo = Foo;
+ foo.fo┃o();
+}After
+struct Foo;
+impl Foo {
+ fn foo(&self) {}
+}
+fn main() {
+ let foo = Foo;
+ Foo::foo(&foo);
+}qualify_path
+Source: qualify_path.rs
+If the name is unresolved, provides all possible qualified paths for it.
+Before
+fn main() {
+ let map = HashMap┃::new();
+}After
+fn main() {
+ let map = std::collections::HashMap::new();
+}reformat_number_literal
+Source: number_representation.rs
+Adds or removes separators from integer literal.
+Before
+const _: i32 = 1012345┃;After
+const _: i32 = 1_012_345;remove_dbg
+Source: remove_dbg.rs
+Removes dbg!() macro call.
Before
+fn main() {
+ let x = ┃dbg!(42 * dbg!(4 + 2));┃
+}After
+fn main() {
+ let x = 42 * (4 + 2);
+}remove_hash
+Source: raw_string.rs
+Removes a hash from a raw string literal.
+Before
+fn main() {
+ r#"Hello,┃ World!"#;
+}After
+fn main() {
+ r"Hello, World!";
+}remove_mut
+Source: remove_mut.rs
+Removes the mut keyword.
Before
+impl Walrus {
+ fn feed(&mut┃ self, amount: u32) {}
+}After
+impl Walrus {
+ fn feed(&self, amount: u32) {}
+}remove_parentheses
+Source: remove_parentheses.rs
+Removes redundant parentheses.
+Before
+fn main() {
+ _ = ┃(2) + 2;
+}After
+fn main() {
+ _ = 2 + 2;
+}remove_unused_imports
+Source: remove_unused_imports.rs
+Removes any use statements in the current selection that are unused.
+Before
+struct X();
+mod foo {
+ use super::X┃;
+}After
+struct X();
+mod foo {
+}remove_unused_param
+Source: remove_unused_param.rs
+Removes unused function parameter.
+Before
+fn frobnicate(x: i32┃) {}
+
+fn main() {
+ frobnicate(92);
+}After
+fn frobnicate() {}
+
+fn main() {
+ frobnicate();
+}reorder_fields
+Source: reorder_fields.rs
+Reorder the fields of record literals and record patterns in the same order as in +the definition.
+Before
+struct Foo {foo: i32, bar: i32};
+const test: Foo = ┃Foo {bar: 0, foo: 1}After
+struct Foo {foo: i32, bar: i32};
+const test: Foo = Foo {foo: 1, bar: 0}reorder_impl_items
+Source: reorder_impl_items.rs
+Reorder the items of an impl Trait. The items will be ordered
+in the same order as in the trait definition.
Before
+trait Foo {
+ type A;
+ const B: u8;
+ fn c();
+}
+
+struct Bar;
+┃impl Foo for Bar┃ {
+ const B: u8 = 17;
+ fn c() {}
+ type A = String;
+}After
+trait Foo {
+ type A;
+ const B: u8;
+ fn c();
+}
+
+struct Bar;
+impl Foo for Bar {
+ type A = String;
+ const B: u8 = 17;
+ fn c() {}
+}replace_arith_with_checked
+Source: replace_arith_op.rs
+Replaces arithmetic on integers with the checked_* equivalent.
Before
+fn main() {
+ let x = 1 ┃+ 2;
+}After
+fn main() {
+ let x = 1.checked_add(2);
+}replace_arith_with_saturating
+Source: replace_arith_op.rs
+Replaces arithmetic on integers with the saturating_* equivalent.
Before
+fn main() {
+ let x = 1 ┃+ 2;
+}After
+fn main() {
+ let x = 1.saturating_add(2);
+}replace_arith_with_wrapping
+Source: replace_arith_op.rs
+Replaces arithmetic on integers with the wrapping_* equivalent.
Before
+fn main() {
+ let x = 1 ┃+ 2;
+}After
+fn main() {
+ let x = 1.wrapping_add(2);
+}replace_char_with_string
+Source: replace_string_with_char.rs
+Replace a char literal with a string literal.
+Before
+fn main() {
+ find('{┃');
+}After
+fn main() {
+ find("{");
+}replace_derive_with_manual_impl
+Source: replace_derive_with_manual_impl.rs
+Converts a derive impl into a manual one.
Before
+#[derive(Deb┃ug, Display)]
+struct S;After
+#[derive(Display)]
+struct S;
+
+impl Debug for S {
+ ┃fn fmt(&self, f: &mut Formatter) -> Result<()> {
+ f.debug_struct("S").finish()
+ }
+}replace_if_let_with_match
+Source: replace_if_let_with_match.rs
+Replaces a if let expression with a match expression.
Before
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+ ┃if let Action::Move { distance } = action {
+ foo(distance)
+ } else {
+ bar()
+ }
+}After
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+ match action {
+ Action::Move { distance } => foo(distance),
+ _ => bar(),
+ }
+}replace_is_some_with_if_let_some
+Source: replace_is_method_with_if_let_method.rs
+Replace if x.is_some() with if let Some(_tmp) = x or if x.is_ok() with if let Ok(_tmp) = x.
Before
+fn main() {
+ let x = Some(1);
+ if x.is_som┃e() {}
+}After
+fn main() {
+ let x = Some(1);
+ if let Some(${0:x}) = x {}
+}replace_let_with_if_let
+Source: replace_let_with_if_let.rs
+Replaces let with an if let.
Before
+
+fn main(action: Action) {
+ ┃let x = compute();
+}
+
+fn compute() -> Option<i32> { None }After
+
+fn main(action: Action) {
+ if let Some(x) = compute() {
+ }
+}
+
+fn compute() -> Option<i32> { None }replace_match_with_if_let
+Source: replace_if_let_with_match.rs
+Replaces a binary match with a wildcard pattern and no guards with an if let expression.
Before
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+ ┃match action {
+ Action::Move { distance } => foo(distance),
+ _ => bar(),
+ }
+}After
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+ if let Action::Move { distance } = action {
+ foo(distance)
+ } else {
+ bar()
+ }
+}replace_named_generic_with_impl
+Source: replace_named_generic_with_impl.rs
+Replaces named generic with an impl Trait in function argument.
Before
+fn new<P┃: AsRef<Path>>(location: P) -> Self {}After
+fn new(location: impl AsRef<Path>) -> Self {}replace_qualified_name_with_use
+Source: replace_qualified_name_with_use.rs
+Adds a use statement for a given fully-qualified name.
+Before
+fn process(map: std::collections::┃HashMap<String, String>) {}After
+use std::collections::HashMap;
+
+fn process(map: HashMap<String, String>) {}replace_string_with_char
+Source: replace_string_with_char.rs
+Replace string literal with char literal.
+Before
+fn main() {
+ find("{┃");
+}After
+fn main() {
+ find('{');
+}replace_try_expr_with_match
+Source: replace_try_expr_with_match.rs
+Replaces a try expression with a match expression.
Before
+fn handle() {
+ let pat = Some(true)┃?;
+}After
+fn handle() {
+ let pat = match Some(true) {
+ Some(it) => it,
+ None => return None,
+ };
+}replace_turbofish_with_explicit_type
+Source: replace_turbofish_with_explicit_type.rs
+Converts ::<_> to an explicit type assignment.
Before
+fn make<T>() -> T { ) }
+fn main() {
+ let a = make┃::<i32>();
+}After
+fn make<T>() -> T { ) }
+fn main() {
+ let a: i32 = make();
+}replace_with_eager_method
+Source: replace_method_eager_lazy.rs
+Replace unwrap_or_else with unwrap_or and ok_or_else with ok_or.
Before
+fn foo() {
+ let a = Some(1);
+ a.unwra┃p_or_else(|| 2);
+}After
+fn foo() {
+ let a = Some(1);
+ a.unwrap_or(2);
+}replace_with_lazy_method
+Source: replace_method_eager_lazy.rs
+Replace unwrap_or with unwrap_or_else and ok_or with ok_or_else.
Before
+fn foo() {
+ let a = Some(1);
+ a.unwra┃p_or(2);
+}After
+fn foo() {
+ let a = Some(1);
+ a.unwrap_or_else(|| 2);
+}sort_items
+Source: sort_items.rs
+Sorts item members alphabetically: fields, enum variants and methods.
+Before
+struct ┃Foo┃ { second: u32, first: String }After
+struct Foo { first: String, second: u32 }+
Before
+trait ┃Bar┃ {
+ fn second(&self) -> u32;
+ fn first(&self) -> String;
+}After
+trait Bar {
+ fn first(&self) -> String;
+ fn second(&self) -> u32;
+}+
Before
+struct Baz;
+impl ┃Baz┃ {
+ fn second(&self) -> u32;
+ fn first(&self) -> String;
+}After
+struct Baz;
+impl Baz {
+ fn first(&self) -> String;
+ fn second(&self) -> u32;
+}+
There is a difference between sorting enum variants:
+Before
+enum ┃Animal┃ {
+ Dog(String, f64),
+ Cat { weight: f64, name: String },
+}After
+enum Animal {
+ Cat { weight: f64, name: String },
+ Dog(String, f64),
+}and sorting a single enum struct variant:
+Before
+enum Animal {
+ Dog(String, f64),
+ Cat ┃{ weight: f64, name: String }┃,
+}After
+enum Animal {
+ Dog(String, f64),
+ Cat { name: String, weight: f64 },
+}split_import
+Source: split_import.rs
+Wraps the tail of import into braces.
+Before
+use std::┃collections::HashMap;After
+use std::{collections::HashMap};toggle_ignore
+Source: toggle_ignore.rs
+Adds #[ignore] attribute to the test.
Before
+┃#[test]
+fn arithmetics {
+ assert_eq!(2 + 2, 5);
+}After
+#[test]
+#[ignore]
+fn arithmetics {
+ assert_eq!(2 + 2, 5);
+}unmerge_match_arm
+Source: unmerge_match_arm.rs
+Splits the current match with a | pattern into two arms with identical bodies.
Before
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+ match action {
+ Action::Move(..) ┃| Action::Stop => foo(),
+ }
+}After
+enum Action { Move { distance: u32 }, Stop }
+
+fn handle(action: Action) {
+ match action {
+ Action::Move(..) => foo(),
+ Action::Stop => foo(),
+ }
+}unmerge_use
+Source: unmerge_use.rs
+Extracts single use item from use list.
+Before
+use std::fmt::{Debug, Display┃};After
+use std::fmt::{Debug};
+use std::fmt::Display;unnecessary_async
+Source: unnecessary_async.rs
+Removes the async mark from functions which have no .await in their body.
+Looks for calls to the functions and removes the .await on the call site.
Before
+pub async f┃n foo() {}
+pub async fn bar() { foo().await }After
+pub fn foo() {}
+pub async fn bar() { foo() }unqualify_method_call
+Source: unqualify_method_call.rs
+Transforms universal function call syntax into a method call.
+Before
+fn main() {
+ std::ops::Add::add┃(1, 2);
+}After
+use std::ops::Add;
+
+fn main() {
+ 1.add(2);
+}unwrap_block
+Source: unwrap_block.rs
+This assist removes if...else, for, while and loop control statements to just keep the body.
+Before
+fn foo() {
+ if true {┃
+ println!("foo");
+ }
+}After
+fn foo() {
+ println!("foo");
+}unwrap_result_return_type
+Source: unwrap_result_return_type.rs
+Unwrap the function's return type.
+Before
+fn foo() -> Result<i32>┃ { Ok(42i32) }After
+fn foo() -> i32 { 42i32 }unwrap_tuple
+Source: unwrap_tuple.rs
+Unwrap the tuple to different variables.
+Before
+fn main() {
+ ┃let (foo, bar) = ("Foo", "Bar");
+}After
+fn main() {
+ let foo = "Foo";
+ let bar = "Bar";
+}wrap_return_type_in_result
+Source: wrap_return_type_in_result.rs
+Wrap the function's return type into Result.
+Before
+fn foo() -> i32┃ { 42i32 }After
+fn foo() -> Result<i32, ${0:_}> { Ok(42i32) }Diagnostics
+While most errors and warnings provided by rust-analyzer come from the
+cargo check integration, there’s a growing number of diagnostics
+implemented using rust-analyzer’s own analysis. Some of these
+diagnostics don’t respect #[allow] or \#[deny] attributes yet, but
+can be turned off using the rust-analyzer.diagnostics.enable,
+rust-analyzer.diagnostics.experimental.enable or
+rust-analyzer.diagnostics.disabled settings.
Clippy
+To run cargo clippy instead of cargo check, you can set
+"rust-analyzer.check.command": "clippy".
break-outside-of-loop
+Source: break_outside_of_loop.rs
+This diagnostic is triggered if the break keyword is used outside of a loop.
expected-function
+Source: expected_function.rs
+This diagnostic is triggered if a call is made on something that is not callable.
+inactive-code
+Source: inactive_code.rs
+This diagnostic is shown for code with inactive #[cfg] attributes.
incoherent-impl
+Source: incoherent_impl.rs
+This diagnostic is triggered if the targe type of an impl is from a foreign crate.
+incorrect-ident-case
+Source: incorrect_case.rs
+This diagnostic is triggered if an item name doesn't follow Rust naming convention.
+invalid-derive-target
+Source: invalid_derive_target.rs
+This diagnostic is shown when the derive attribute is used on an item other than a struct,
+enum or union.
macro-error
+Source: macro_error.rs
+This diagnostic is shown for macro expansion errors.
+macro-error
+Source: macro_error.rs
+This diagnostic is shown for macro expansion errors.
+malformed-derive
+Source: malformed_derive.rs
+This diagnostic is shown when the derive attribute has invalid input.
+mismatched-arg-count
+Source: mismatched_arg_count.rs
+This diagnostic is triggered if a function is invoked with an incorrect amount of arguments.
+mismatched-tuple-struct-pat-arg-count
+Source: mismatched_arg_count.rs
+This diagnostic is triggered if a function is invoked with an incorrect amount of arguments.
+missing-fields
+Source: missing_fields.rs
+This diagnostic is triggered if record lacks some fields that exist in the corresponding structure.
+Example:
+struct A { a: u8, b: u8 }
+
+let a = A { a: 10 };missing-match-arm
+Source: missing_match_arms.rs
+This diagnostic is triggered if match block is missing one or more match arms.
missing-unsafe
+Source: missing_unsafe.rs
+This diagnostic is triggered if an operation marked as unsafe is used outside of an unsafe function or block.
moved-out-of-ref
+Source: moved_out_of_ref.rs
+This diagnostic is triggered on moving non copy things out of references.
+need-mut
+Source: mutability_errors.rs
+This diagnostic is triggered on mutating an immutable variable.
+no-such-field
+Source: no_such_field.rs
+This diagnostic is triggered if created structure does not have field provided in record.
+private-assoc-item
+Source: private_assoc_item.rs
+This diagnostic is triggered if the referenced associated item is not visible from the current +module.
+private-field
+Source: private_field.rs
+This diagnostic is triggered if the accessed field is not visible from the current module.
+replace-filter-map-next-with-find-map
+Source: replace_filter_map_next_with_find_map.rs
+This diagnostic is triggered when .filter_map(..).next() is used, rather than the more concise .find_map(..).
type-mismatch
+Source: type_mismatch.rs
+This diagnostic is triggered when the type of an expression or pattern does not match +the expected type.
+typed-hole
+Source: typed_hole.rs
+This diagnostic is triggered when an underscore expression is used in an invalid position.
+undeclared-label
+Source: undeclared_label.rs
+unimplemented-builtin-macro
+Source: unimplemented_builtin_macro.rs
+This diagnostic is shown for builtin macros which are not yet implemented by rust-analyzer
+unlinked-file
+Source: unlinked_file.rs
+This diagnostic is shown for files that are not included in any crate, or files that are part of +crates rust-analyzer failed to discover. The file will not have IDE features available.
+unnecessary-braces
+Source: useless_braces.rs
+Diagnostic for unnecessary braces in use items.
unreachable-label
+Source: unreachable_label.rs
+unresolved-extern-crate
+Source: unresolved_extern_crate.rs
+This diagnostic is triggered if rust-analyzer is unable to discover referred extern crate.
+unresolved-field
+Source: unresolved_field.rs
+This diagnostic is triggered if a field does not exist on a given type.
+unresolved-import
+Source: unresolved_import.rs
+This diagnostic is triggered if rust-analyzer is unable to resolve a path in
+a use declaration.
unresolved-macro-call
+Source: unresolved_macro_call.rs
+This diagnostic is triggered if rust-analyzer is unable to resolve the path +to a macro in a macro invocation.
+unresolved-method
+Source: unresolved_method.rs
+This diagnostic is triggered if a method does not exist on a given type.
+unresolved-module
+Source: unresolved_module.rs
+This diagnostic is triggered if rust-analyzer is unable to discover referred module.
+unresolved-proc-macro
+Source: unresolved_proc_macro.rs
+This diagnostic is shown when a procedural macro can not be found. This usually means that +procedural macro support is simply disabled (and hence is only a weak hint instead of an error), +but can also indicate project setup problems.
+If you are seeing a lot of "proc macro not expanded" warnings, you can add this option to the
+rust-analyzer.diagnostics.disabled list to prevent them from showing. Alternatively you can
+enable support for procedural macros (see rust-analyzer.procMacro.attributes.enable).
unused-mut
+Source: mutability_errors.rs
+This diagnostic is triggered when a mutable variable isn't actually mutated.
+unused-variables
+Source: unused_variables.rs
+This diagnostic is triggered when a local variable is not used.
+Editor Features
+VS Code
+Color configurations
+It is possible to change the foreground/background color and font
+family/size of inlay hints. Just add this to your settings.json:
{
+ "editor.inlayHints.fontFamily": "Courier New",
+ "editor.inlayHints.fontSize": 11,
+
+ "workbench.colorCustomizations": {
+ // Name of the theme you are currently using
+ "[Default Dark+]": {
+ "editorInlayHint.foreground": "#868686f0",
+ "editorInlayHint.background": "#3d3d3d48",
+
+ // Overrides for specific kinds of inlay hints
+ "editorInlayHint.typeForeground": "#fdb6fdf0",
+ "editorInlayHint.parameterForeground": "#fdb6fdf0",
+ }
+ }
+}
+Semantic style customizations
+You can customize the look of different semantic elements in the source
+code. For example, mutable bindings are underlined by default and you
+can override this behavior by adding the following section to your
+settings.json:
{
+ "editor.semanticTokenColorCustomizations": {
+ "rules": {
+ "*.mutable": {
+ "fontStyle": "", // underline is the default
+ },
+ }
+ },
+}
+Most themes doesn’t support styling unsafe operations differently yet.
+You can fix this by adding overrides for the rules operator.unsafe,
+function.unsafe, and method.unsafe:
{
+ "editor.semanticTokenColorCustomizations": {
+ "rules": {
+ "operator.unsafe": "#ff6600",
+ "function.unsafe": "#ff6600",
+ "method.unsafe": "#ff6600"
+ }
+ },
+}
+In addition to the top-level rules you can specify overrides for +specific themes. For example, if you wanted to use a darker text color +on a specific light theme, you might write:
+{
+ "editor.semanticTokenColorCustomizations": {
+ "rules": {
+ "operator.unsafe": "#ff6600"
+ },
+ "[Ayu Light]": {
+ "rules": {
+ "operator.unsafe": "#572300"
+ }
+ }
+ },
+}
+Make sure you include the brackets around the theme name. For example,
+use "[Ayu Light]" to customize the theme Ayu Light.
Special when clause context for keybindings.
+You may use inRustProject context to configure keybindings for rust
+projects only. For example:
{
+ "key": "ctrl+alt+d",
+ "command": "rust-analyzer.openDocs",
+ "when": "inRustProject"
+}
+More about when clause contexts
+here.
Setting runnable environment variables
+You can use "rust-analyzer.runnables.extraEnv" setting to define +runnable environment-specific substitution variables. The simplest way +for all runnables in a bunch:
+"rust-analyzer.runnables.extraEnv": {
+ "RUN_SLOW_TESTS": "1"
+}
+Or it is possible to specify vars more granularly:
+"rust-analyzer.runnables.extraEnv": [
+ {
+ // "mask": null, // null mask means that this rule will be applied for all runnables
+ env: {
+ "APP_ID": "1",
+ "APP_DATA": "asdf"
+ }
+ },
+ {
+ "mask": "test_name",
+ "env": {
+ "APP_ID": "2", // overwrites only APP_ID
+ }
+ }
+]
+You can use any valid regular expression as a mask. Also note that a
+full runnable name is something like run bin_or_example_name,
+test some::mod::test_name or test-mod some::mod, so it is
+possible to distinguish binaries, single tests, and test modules with
+this masks: "^run", "^test " (the trailing space matters!), and
+"^test-mod" respectively.
If needed, you can set different values for different platforms:
+"rust-analyzer.runnables.extraEnv": [
+ {
+ "platform": "win32", // windows only
+ env: {
+ "APP_DATA": "windows specific data"
+ }
+ },
+ {
+ "platform": ["linux"],
+ "env": {
+ "APP_DATA": "linux data",
+ }
+ },
+ { // for all platforms
+ "env": {
+ "APP_COMMON_DATA": "xxx",
+ }
+ }
+]
+Compiler feedback from external commands
+Instead of relying on the built-in cargo check, you can configure Code
+to run a command in the background and use the $rustc-watch problem
+matcher to generate inline error markers from its output.
To do this you need to create a new VS Code
+Task and set
+"rust-analyzer.checkOnSave": false in preferences.
For example, if you want to run
+cargo watch instead, you might
+add the following to .vscode/tasks.json:
{
+ "label": "Watch",
+ "group": "build",
+ "type": "shell",
+ "command": "cargo watch",
+ "problemMatcher": "$rustc-watch",
+ "isBackground": true
+}
+Live Share
+VS Code Live Share has partial support for rust-analyzer.
+Live Share requires the official Microsoft build of VS Code, OSS +builds will not work correctly.
+The host’s rust-analyzer instance will be shared with all guests joining +the session. The guests do not have to have the rust-analyzer extension +installed for this to work.
+If you are joining a Live Share session and do have rust-analyzer +installed locally, commands from the command palette will not work +correctly since they will attempt to communicate with the local server.
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/book/book/searcher.js b/docs/book/book/searcher.js
new file mode 100644
index 000000000000..d2b0aeed387b
--- /dev/null
+++ b/docs/book/book/searcher.js
@@ -0,0 +1,483 @@
+"use strict";
+window.search = window.search || {};
+(function search(search) {
+ // Search functionality
+ //
+ // You can use !hasFocus() to prevent keyhandling in your key
+ // event handlers while the user is typing their search.
+
+ if (!Mark || !elasticlunr) {
+ return;
+ }
+
+ //IE 11 Compatibility from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith
+ if (!String.prototype.startsWith) {
+ String.prototype.startsWith = function(search, pos) {
+ return this.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;
+ };
+ }
+
+ var search_wrap = document.getElementById('search-wrapper'),
+ searchbar = document.getElementById('searchbar'),
+ searchbar_outer = document.getElementById('searchbar-outer'),
+ searchresults = document.getElementById('searchresults'),
+ searchresults_outer = document.getElementById('searchresults-outer'),
+ searchresults_header = document.getElementById('searchresults-header'),
+ searchicon = document.getElementById('search-toggle'),
+ content = document.getElementById('content'),
+
+ searchindex = null,
+ doc_urls = [],
+ results_options = {
+ teaser_word_count: 30,
+ limit_results: 30,
+ },
+ search_options = {
+ bool: "AND",
+ expand: true,
+ fields: {
+ title: {boost: 1},
+ body: {boost: 1},
+ breadcrumbs: {boost: 0}
+ }
+ },
+ mark_exclude = [],
+ marker = new Mark(content),
+ current_searchterm = "",
+ URL_SEARCH_PARAM = 'search',
+ URL_MARK_PARAM = 'highlight',
+ teaser_count = 0,
+
+ SEARCH_HOTKEY_KEYCODE = 83,
+ ESCAPE_KEYCODE = 27,
+ DOWN_KEYCODE = 40,
+ UP_KEYCODE = 38,
+ SELECT_KEYCODE = 13;
+
+ function hasFocus() {
+ return searchbar === document.activeElement;
+ }
+
+ function removeChildren(elem) {
+ while (elem.firstChild) {
+ elem.removeChild(elem.firstChild);
+ }
+ }
+
+ // Helper to parse a url into its building blocks.
+ function parseURL(url) {
+ var a = document.createElement('a');
+ a.href = url;
+ return {
+ source: url,
+ protocol: a.protocol.replace(':',''),
+ host: a.hostname,
+ port: a.port,
+ params: (function(){
+ var ret = {};
+ var seg = a.search.replace(/^\?/,'').split('&');
+ var len = seg.length, i = 0, s;
+ for (;i
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Privacy
+The LSP server performs no network access in itself, but runs
+cargo metadata which will update or download the crate registry and
+the source code of the project dependencies. If enabled (the default),
+build scripts and procedural macros can do anything.
The Code extension does not access the network.
+Any other editor plugins are not under the control of the
+rust-analyzer developers. For any privacy concerns, you should check
+with their respective developers.
For rust-analyzer developers, cargo xtask release uses the GitHub
+API to put together the release notes.