Настройка visual studio code для rust
Adds language support for Rust to Visual Studio Code. Supports:
- code completion
- jump to definition, peek definition, find all references, symbol search
- types and documentation on hover
- code formatting
- refactoring (rename, deglob)
- error squiggles and apply suggestions from errors
- snippets
- build tasks
Rust support is powered by a separate language server - either by the official Rust Language Server (RLS) or rust-analyzer, depending on the user's preference. If you don't have it installed, the extension will install it for you (with permission).
This extension is built and maintained by the Rust IDEs and editors team. Our focus is on providing a stable, high quality extension that makes the best use of the respective language server. We aim to support as many features as possible, but our priority is supporting the essential features as well as possible.
For support, please file an issue on the repo or talk to us on Discord. For RLS, there is also some troubleshooting and debugging advice.
Contribution
Contributing code, tests, documentation, and bug reports is appreciated! For more details see contributing.md.
Quick start
Configuration
This extension provides options in VSCode's configuration settings. These include rust.* , which are passed directly to RLS, and the rust-client.* , which mostly deal with how to spawn it or debug it. You can find the settings under File > Preferences > Settings ; they all have IntelliSense help.
TIP: To select the underlying language server, set rust-client.engine accordingly!
Features
Snippets
Snippets are code templates which expand into common boilerplate. IntelliSense includes snippet names as options when you type; select one by pressing enter. You can move to the next snippet 'hole' in the template by pressing tab. We provide the following snippets:
- for - a for loop
- macro_rules - declare a macro
- if let - an if let statement for executing code only when a pattern matches
- spawn - spawn a thread
- extern crate - insert an extern crate statement
This extension is deliberately conservative about snippets and doesn't include too many. If you want more, check out Trusty Rusty Snippets.
Tasks
The plugin provides tasks for building, running, and testing using the relevant cargo commands. You can build using ctrl+shift+b. Access other tasks via Run Task in the command palette.
The plugin writes these into tasks.json . The plugin will not overwrite existing tasks, so you can customise these tasks. To refresh back to the defaults, delete tasks.json and restart VSCode.
Format on save
To enable formatting on save, you need to set the editor.formatOnSave setting to true . Find it under File > Preferences > Settings .
Requirements
-
,
- A Rust toolchain (the extension will configure this for you, with permission),
- rls , rust-src , and rust-analysis components (the extension will install these for you, with permission). Only rust-src is required when using rust-analyzer.
Implementation
Both language servers can use Cargo to get more information about Rust projects and both use rustfmt extensively to format the code.
RLS uses Cargo and also the Rust compiler ( rustc ) in a more direct fashion, where it builds the project and reuses the data computed by the compiler itself. To provide code completion it uses a separate tool called racer .
Rust Analyzer is a separate compiler frontend for the Rust language that doesn't use the Rust compiler ( rustc ) directly but rather performs its own analysis that's tailor-fitted to the editor/IDE use case.
Нет денег на CLion или Intellij Ultimate, но тебе нужно отлаживать код?
Очень нравится Visual Studio Code, но при виде десятков плагинов разбегаются глаза?
Если на любой из вопросов выше ты ответил "да", то эта статья для тебя.
Во многом эта статья обращена мне самому в прошлом, когда я долго мучался с настройкой vscode и плевался от кучи конфликтов и непонятных ошибок.
На данный момент я использую CLion с плагином Intellij Rust
А, ну и это моя первая статья в принципе, так что любая критика и вопросы приветствуются.
Устанавливаем тулчейн
Это самое простое, и при этом самое важное, без этого не получится собрать твой прекрасный код.
Скачай и установи Инструменты сборки для Visual Studio отсюда:
Листаем вниз до пункта "Инструменты для Visual Studio 2022" Нам нужная самая последняя кнопка, напротив "Инструменты сборки для Visual Studio 2022" После запуска и некоторого ожидания откроется Visual Studio Installer В нём нам нужен пункт "Разработка классических приложений на C++"
При каждом запросе на перезагрузку - перезагружайся.
Тут тебе ничего не надо менять - просто пиши 1 и жми [Enter].
После этого тебе установится cargo и rustc, с помощью которых ты сможешь собирать код из консоли.
Устанавливаем и настраиваем Visual Studio Code
Теперь нам нужно научить его работать с Rust, это делается при помощи расширений.
Нам понадобятся расширения для подсветки синтаксиса и автодополнений, отладки, и что-то ещё для комфортного редактирования cargo.toml.
Для подсветки синтаксиса и автодополнений есть два наиболее популярных расширения: Rust и rust-analyzer. Они работают немного по-разному и конфликтуют между собой. Я не буду глубоко разбирать, в чём у них различия, но rust-analyzer работает лучше, потому берём его.
Для отладки устанавливаем CodeLLDB.
Для работы с toml ставим Even Better TOML (для подсветки), crates (для удобного обновления зависимостей), и crates completer (для автодополнения имён пакетов и версий)
Также, тебе может пригодится Test Explorer UI и Rust Test Explorer для того чтобы запускать тесты из боковой панели, а не из консоли.
Проверяем всё вместе
Создаём пустой проект в консоли
В результате у тебя откроется vscode с твоим проектом
Для того чтобы просто запустить - нажимай Run.
Для того чтобы запустить в режиме отладки - жми Debug.
Также можно создать launch.json через раздел Run and Debug (четвёртая иконка на боковой панели на скриншоте).
UPD1: Спасибо @TrueBersза поправку, что Better TOML устарел, и вместо него надо использовать Even Better TOML
В моей предыдущей статье о rust я попытался рассказать об истории языка, и показать откуда он пришёл. В статье было сделано множество упрощений. Просто нереальное множество. Народу не понравилось. Но в опросе, в конце статьи вы сказали, что надо бы показать кишки компилятора. Ну что же, под катом вы найдёте разбор исходных кодов компилятора rust. Мы проследим путь программы, начиная из исходного файла, прямиком к бинарнику.
Словарь
Далее по тексту я буду разбрасываться следующими терминами без удержи. Если вы знаете что это всё значит - хорошо. Если нет, убедитесь что подтянули свои знания, перед тем как заныривать.
LLVM - система компиляции которая состоит из компилятора и набора инструментов, позволяющая создавать фронт-энд для любого языка и компилировать его на множество различных платформ.
AST - (abstract syntax tree) древовидная репрезентация семантической структуры исходного кода. Каждый узел обычно показывает конструкцию, встречающуюся в коде.
IR (intermediate representation) - Структура данных, обычно используемая в кишках компилятора или виртуальной машины, для представления исходного кода программы. Такую структуру обычно оптимизируют и перегоняют в конечный код.
HIR (High Level IR) - IR высокого уровня. Это основная репрезентация кода, используемая в rust. Фактически это представление AST, которым компилятору удобно пользоваться.
MIR (Mid Level IR) - Это репрезентация HIR, которая намного ближе к LLVMIR.
LLVMIR (Language Independent IR) - фактически это высокоуровневый ассемблер, который не привязан к определённому языку или системе. Такой код удобно оптимизировать и после он передаётся компилятору.
Крейт, crate - Это то, что будет скомпилировано либо в библиотеку или бинарник. На выходе будет одна библиотека или бинарник, вне зависимости от того, сколько файлов входят в крейт.
ICE (Internal compiler error), ошибка компилятора.
Дальнейший текст подразумевает, что вы умеете программировать. Можно и не на rust.
Начало
Поехали. Мы будем лезть нашими ручками в сам компилятор и смотреть на его исходники. Для начала нам понадобятся кое-какие инструменты. Ставим чистую виртуальную машину с Windows 10. Идём в интернеты и льём следующее:
Сорцы компилятора. Достаются с github. Можно лить просто zip, ибо обратно коммитить мы ничего не будем.
Установщик компилятора. Любая свежая стабильная версия подойдёт.
Не будем мучиться, давайте, заодно, установим nightly компилятор.
rustup toolchain install nightly --allow-downgrade --profile minimal --component clippy rustup default nightly
Guide to Rustc Development. Инструкция по разработке компилятора. 460 страниц. Не хило. Сохраняем pdf.
Ну и хорошо. Этого, для начала достаточно. Отключаемся от проводного интернета, хватаем ноутбук и идём на веранду, сидеть и погружаться. Начинаем погружаться, понимаем что будет глупо говорить о компиляторе, если мы не скомпилируем хоть что-то. Ок, так и сделаем.
Ок, это было просто. Но мы не будем использовать cargo для самой компиляции. Используем компилятор напрямую. Но я же на надо cargo издеваюсь, так ведь?
Отступление по теме
Как не надо устанавливать rust
Чего? Так, сам по себе компилятор всё собрал, но ругается на отсутствие линкера. От жеж, зараза. То есть, линкер ему нужен внешний. Ругаемся на компилятор, встаём с удобного кресла и идём обратно, подключаться к проводному интернету, потому что палить 5 гигов установщика Visual Studio Build Tools не хочется на хотспоте.
Билдим всё ещё раз и смотрим.
Ширина и жирина файлов.
Ах, ты, ржавая банка! Какого чёрта?? Я уже как две недели рассказываю всем обитателям Хабра о том, какой ты прекрасный компилятор, и как хорошо ты собираешь минимальные бинарники, а ты. 150 килобайт исполняемого кода из-за одной только линии текста на экране?
Пытаемся скомпилировать с -C opt-level=3 и получаем то же самое. Что случилось с бинарником? Сейчас на этот вопрос отвечать не будем. Мотаем на Ус и едем дальше.
Копирайт - сдесь же.
Ус недоволен. На него и так уже много чего намотано, он не понимает, почему ему надо разбираться с исходниками раста теперь.
Ладно, что мы знаем? Компилятор не работает без внешнего линкера и исходник для вывода одной строки текста раздувается до 150 килобайт. Ну, по крайней мере мы это можем скомпилировать. Давайте пока распакуем исходники компилятора и начнём рыться. (Собирать компилятор я не собираюсь. Если вам очень хочется - это можно сделать, но процесс это долгий и утомительный.)
Шаг первый: rustc
Открываем сорцы и наслаждаемся. Всё выглядит очень прилично и чисто. Тут, понятное дело, можно учиться тому как правильно разделять свой проект на куски и как правильно управлять кодом на rust. Собственно говоря, сразу понятно куда идти. Забираемся в compiler/rustc/src/main.rs и смотрим.
Всё только начинается. Держитесь.
Хм. То есть точка входа в программу просто тянет jemalloc вызовы и запускает ещё две функции. Ну вот, всё. Теперь понятно как работает компилятор rust. Делов-то! Кстати, jemalloc это специальный менеджер памяти, изначально разработанный для FreeBSD в 2005 году. Основной упор был сделан на то, чтобы избежать фрагментации памяти при работе с этим аллокатором. В оригинальной версии он просто заменяет malloc. В 2007 году Firefox начал использовать этот менеджер для снижения расхода памяти, а ещё через пару лет он попал в Facebook.
Шаг второй: rustc-driver
Ладно, всё выглядит слишком уж просто. Погружаемся дальше. rustc тянет за собой rustc-driver. Ныряем туда.
Тут мы найдём небольшой readme, который расскажет нам о том, что компилятора в самом драйвере мы не найдём. Эта программа собирает конфигурацию из аргументов и запускает сам процесс компиляции из других крейтов. После изучения исходников находим функцию для запуска процесса компиляции.
Да, в этом крейте файлов не так-то много, но что бы тут не творилось, на самом деле всё сводится к вызову методов в крейте под названием interface. Вышеприведённый код это и показывает. interface::run_compiler и поехали.
Что же произошло в rustc-driver? Мы собрали все конфиги. Подгрузили все файлы и нашли их местоположение в файловой системе. Создали замыкание, которое следит за процессом компиляции и запускает линкер после успешной компиляции. Запустили линтеры (если такие имелись) и приготовили сам компилятор к запуску. Давайте запускать.
Шак третий: rustc-interface
Ага. Тут мы уже ближе к самому процессу компиляции. Все конфиги подъедены, файлы тоже замеплены. Смотрим на исходники интерфейса. Их хоть и не так-то много, но это наш центральный вокзал, где куча других крейтов собирается воедино.
Так, осматриваемся и находим
Кстати тут же, недалеко, мы можем найти настройку механизма кодогенерации.
Быстренько посмотрим на наши сорцы и увидим что у нас прямо в сорцах есть 3 различных модуля кодогенерации. Что они делают? Превращают MIR в конечный код для системы компиляции. Открываем rustc-codegen-llvm и смотрим в README:
Ок, ну тут всё понятно, мы берём MIR и переделываем его в LLVM IR. После этого LLVM может скомпилировать код в конечный бинарник. Но погодите, помимо LLVM бекенда у нас есть ещё два других! Смотрим туда. rustc-codegen-ssa согласно документации, позволяет генерировать низкоуровневый код, который не будет привязан к определённому бекэнду (например, LLVM) и позволит в дальнейшем использовать другие системы компиляции.
Собственно говоря, прямо там же вы найдёте rustc-codegen-cranelift. То есть MIR в будущем может компилироваться через cranelift, который в идеале ускорит процесс компиляции. Ну это в будущем, пока что проект в процессе тестирования и работает не лучше, чем Газель без мотора.
Открываем модуль и смотрим, что происходит внутри:
Ага, вот тут мы берём быка за рога и начинаем разбирать исходный код на части. Далее, создаём и проверяем AST
И вот тут у нас начинается полное мясо. Прикол вот в чём, обычно компиляторы делают достаточно простую вещь - берёшь сорцы, проходишься по ним несколько раз, парсишь синтаксис, находишь ошибки, разбираешь на куски макросы, всё хорошо. rust в стародавние времена начинал именно так же. Но, со временем, была предложена новая модель компиляции. Запросы. Вместо того чтобы делать всю работу несколько раз подряд, давайте просто превратим проходы в запросы. Результат запроса можно сохранить в кеш. Если пользователь (программист) не менял ничего в определённом файле, то и компилировать его не надо. Если мы видим что делать это не надо, мы просто возвращаем данные из кеша запроса.
Даже если вы и поменяли что-то в каком-либо файле, то благодаря системе запросов вы сможете избежать ненужной перекомпиляции. Что если вы изменили только одну линию в комментариях к файлу? Пересобирать такой не придётся.
Давайте посмотрим на запросы, которые создаёт компилятор:
Парсинг, создание крейта, сбор HIR - всё это делается через запросы. Один момент про который полезно знать, это то что ещё не всё переписано на запросах.
В итоге у нас на выходе получается большая и толстая структура:
И как раз её можно дёргать для выполнения необходимых запросов.
Шаг четвёртый: rustc-parse и rustc-lexer
Далее по тексту вы найдёте простую логику всех этих запросов. "Простая" логика заключается в вызове крейтов, которые её обрабатывают. Например, rustc-parse. Это крейт, который использует rustc-lexer. Лексер читает строки из файлов и преобразовывает их в очень простые токены. Токены передаются парсеру, который превращает их в Span и продолжает работу с кодом. Основной момент этого Span заключается в том, что к каждому элементу в дереве кода будет добавлена информация о том, в каком конкретно месте этот элемент записан в исходном файле. Когда компилятор будет сообщать об ошибке, вы увидите, где именно эта ошибка произошла.
Основная часть парсера запускается через вызов parse_crate_mod в rustc_parse\src\parser\item.rs . А дальше по тексту вы найдёте невероятное количество проверок синтаксиса, который этот парсер делает. Вот, например:
Шаг пятый: rustc-expand
В результате работы парсера мы получаем наш самый великий и могучий AST.
Всё это создаётся огромным макросом astfragments! в \compiler\rustcexpand\src\expand.rs
AST используется для дальнейшей генерации кода и приведения его в нужный вид. Про это можно писать отдельную книгу. Но мы пока удовольствуемся там, что AST можно разобрать до HIR.
Шаг шестой: rustc-middle
Куда ты завёл нас? Не видно ни зги! Простите, ребята, не варят мозги. Вернее, мозг начинает вариться. Сложность процесса увеличивается настолько, что просто читая коды дальше ходить страшно. Ладно, обратимся к инструкции для разработчиков - смотрим. Видим что после того как у нас появился AST мы можем заняться приведением его в приличный вид. Вернее, в HIR.
Этим как раз и занимается rustc-middle. Вернее, не только этим. Залезаем в исходники и видим что тут у нас есть HIR, MIR и Types.
Что же происходит в реальности? Ну, для начала мы начинаем обработку AST. Этим, кстати занимается ещё один модуль, rust_ast_lowering . Смотрим туда и находим достаточно длинный файл, в котором и происходит преобразование каждого элемента AST в HIR.
Здесь весь синтаксический сахар растворяется в чае и перестаёт быть сахаром. Так моя любимая for node in data превращается в
А вот здесь, как раз, всеми любимый оператор ? первращается в Try::into_result :
С HIR теперь можно работать…
Шаг седьмой: rustc_ty
И .\rust-master\compiler\rustc_middle\src\ty\mod.rs . Одна из самых больших частей компилятора занимается проверками системы типов после того, как у нас есть HIR. Какой тип будет у let mut a = 5; ? Вот на этот вопрос и ответит наша система работы с типами. Две основных структуры здесь:
Последняя тянется через весь процесс компиляции.
Файл просто огромный. Нам надо вычислить типы каждой переменной, замыкания и трейта. Сам модуль занимает более 3000 строк, не считая остальные файлы в директории.
Кстати, смотрим в rust-master\compiler\rustc_typeck\src\check\expr.rs
Хмм.. Если мы натыкаемся на брейк, после которого есть только один лейбл - rust то нужно запустить функцию fatally_break_rust .
Компилируем и запускаем:
Пасхалки они выглядят именно вот так.
Так, вычислили типы и теперь можем проверить что никто не пытается запихнуть строку в Int. Хорошо. Можно идти дальше.
Шаг восьмой: rustc_mir и rustc_mir_build
Теперь наш HIR можно преобразовать в MIR. Берём ранее созданный TyCtxt и начинаем преобразовывать его в
И так далее по всем нодам. MIR это намного более генерализированная версия HIR. Она очень близка к тому что требует от нас LLVM для компиляции. В результате этой генерализации мы можем намного более эффективно работать над оптимизацией написанного вами кода и заниматься проверками заимствований и оптимизацией.
Шаг девятый: Проверка заимствования
Самая "страшная" функция rust это всем известный borrow cheker. Сам он живёт в
В rust-master\compiler\rustc_mir\src\borrow_check\mod.rs . Да, сам модуль такой же огромный и страшный, как и borrow checker. А вот тут, например, можно найти всю логику проверки заимствования при перемещении переменных rust-master\compiler\rustc_mir\src\borrow_check\diagnostics\move_errors.rs
Шаг десятый: Оптимизации
Про систему оптимизаций в rust можно писать отдельную книгу. Всё аккуратно сложено в rust-master\compiler\rustc_mir\src\transform . LLVM сам по себе не сможет оптимизировать некоторые высокоуровневые примитивы, о которых знает только rust. И вот тут мы как раз и занимаемся оптимизацией этих примитивов.
Шак одиннадцатый: прощай, rust!
Полученный оптимизированный MIR можно теперь переделать в LLVM IR. Поехали. rustc-codegen-llvm создаёт LLVM-IR на базе MIR, который мы сгенерировали на предыдущем этапе. Здесь заканчивается rust и начинается llvm. Хотя, мы ещё не закончили с сорцами компилятора.
Тут можно найти пару интересных моментов, например rust-master\compiler\rustc_codegen_llvm\src\asm.rs содержит код для компилирования ассемблера напрямую из rust. Даже не замечал этого. Смотрим в документацию - есть такая поддержка в этом компиляторе!
Копаемся чуть глубже и находим rustc-target в котором видим различные дополнительные классы для работы с определённым ассемблером.
После того как кодогенерация завершена, мы можем передать IR в сам LLVM. rustc_llvm нам в помощь.
Вот, собственно говоря, и всё, ребята! LLVM за пределами нашей видимости. На моей операционной системе Visual Studio Build Tools берут на себя контроль и перегоняют LLVMIR в обычный бинарник.
Процесс компиляции в rust - это вам не мешки ворочать. Надо проверить неимоверное количество разных вещей. Вот что происходит с вашим кодом:
Он парсится из текста в AST.
AST обрабатывается и оптимизируется в HIR
HIR обрабатывается и оптимизируется в MIR.
MIR делает проверки заимствования и оптимизацию и перегоняется в LLVMIR.
LLVMIR компилируется на конечной платформе.
Пробуем ручками
Ну что же, напоследок осталось написать простенькую программку, типа этого:
И начать её компилировать, только показывая все внутренности. Для начала есть замечательная опция компилятора, которая работает на любой версии:
Значит, запуская компиляцию следующим образом:
Мы получаем на выходе мириады различных форматов, включая сгенерированный ассемблеровский код, байткод и IR для LLVM, и даже челвоеко-читаемый MIR.
А если у вас есть nightly компилятор, то вы можете запустить
И полюбоваться вашим HIR, в то время как
Даст вам возможность посмотреть на то, как выглядит AST.
Напоследок
Понятно? Ну и хорошо.
Постскриптум
А почему бинарник такой-то большой? Ну, на этот вопрос можно ответить легко. Залезаем вашим любимым дебаггером в .pdb файл и смотрим на указатели функций, которые тянутся в наш бинарник. Их много. Подсистема работы со строками, макросами и памятью. Плюс система ввода-вывода. Что, считаете что 150 килобайт - слишком много?
Вы можете установить Rust, просто скачав инсталлятор и дважды кликнув по нему. Хотя разработчикам, имеющим дело с более сложными инструментами, или тем, кому нужно собирать "небезопасные" (unsafe) C/C++ библиотеки из исходников, предстоит сделать немного больше. Тем не менее, если проявить немного упорства, разобраться в этом вполне реально.
Во время всего этого процесса следите за тем, что вы устанавливаете правильную версию библиотек: в данный момент для MSVC доступна только 64-битная версия Rust. Вы будете то и дело получать странные ошибки, если попробуете использовать 32-битные библиотеки. Поверьте мне.
Повторюсь: если вам нужен компилятор Rust, идите на официальный сайт и жмите "Install". Если же вы планируете работать с нативными C/C++ библиотеками, читайте дальше!
Rust на Windows – что нам понадобится
Компилятор С
Перейдем к трудной части: вам потребуется заставить магию Visual C++ работать в вашем окружении. Для облегчения этой задачи в Visual C++ существует много переменных окружения и сложных установочных скриптов. Можно использовать командную оболочку, которую Microsoft предоставляет вместе с VS and VC++ (Visual C++ 2015 x64 Native Build Tools Command Prompt). Всё, о чём речь пойдёт ниже, будет работать, если вы выберете эту опцию.
Я применяю cmder, который использует PowerShell, поэтому, чтобы заставить инструменты командной строки работать в моем окружении, мне пришлось преодолеть еще одну преграду. Я выбрал рецепт Retain Changes to Environment Variables Set by a Batch File из книги PowerShell Cookbook (вам обязательно нужно купить ее, если вам нравится этот пример кода, в ней вы найдете много строк кода на PowerShell, который не придется писать самостоятельно). В любом случае, после сохранения рецепта в файл я добавил в мой PowerShell профиль следующее:
OpenSSL
Если вы хотите использовать Rust в качестве серверного языка для веб-разработки, вам понадобится OpenSSL. Win32 OpenSSL Installation Project поддерживает несколько инсталляторов. Перейдите по ссылке и пролистайте до “Download Win32 OpenSSL”. Выберите 64-битную версию OpenSSL (не Light). Установите ее.
Переменные окружения OpenSSL
Убедитесь в том, что компилятор видит OpenSSL. Вам следует настроить следующие переменные окружения:
Очевидно, это подразумевает, что вы поместили OpenSSL в стандартную директорию установки C:\OpenSSL-Win64.
Freetype
C инструкциями по настройке Freetype для работы c MSVC вы можете ознакомиться здесь.
Установка Rust на Windows
Можно пойти двумя путями: используя инсталлятор Rust или multirust.
Инсталлятор Rust
Зайдите на страницу загрузки Rust и скачайте инсталлятор MSVC ABI.
Так вы получите одну из версий Rust (например, 1.7.0). Когда появятся новые версии языка, вам придется решить, хотите ли вы обновиться и, как следствие, поменять одну или несколько переменных окружения. Это несложно, но, поскольку релизы Rust выпускаются раз в шесть недель, возможно, вас немного утомят частые изменения языка.
Rustup
Rustup – это инструмент для поддержания нескольких версий Rust на одной операционной системе. Благодаря ему вы сможете использовать различные версии Rust для разных проектов и даже потестировать новые возможности в ночной версии!
Теперь посетите сайт rustup.rs и скачайте текущий инсталлятор. После загрузки дважды кликните по нему и подождите. Когда она завершится, откройте новый терминал и запустите rustup default stable-x86_64-stable .
Нам нужно убедиться, что переменная окружения установлена. Думаю, вы знаете, где ее искать. Проверьте PATH , чтобы увидеть, был ли добавлен путь ~/.cargo/bin . Я использую ~ для обозначения вашей домашней директории. У себя на компьютере я проверяю, есть ли C:\Users\jeremiah\.cargo\bin в PATH . Если нет, добавьте его.
Дополнительные инструменты Rust
На этом этапе у нас уже установлена рабочая версия Rust. Мы можем начать использовать rustc и cargo для разработки программного обеспечения. Однако, мы можем установить дополнительные инструменты, чтобы облегчить себе работу.
Исходный код Rust
Вы можете с ним ознакомиться, но сейчас мы просто хотим использовать его для некоторых дополнительных инструментов. Зайдите на страницу загрузок Rust и скачайте исходники. Это файл .tar.gz, так что вам может понадобиться что-то вроде 7-zip. Выбор конкретной программы я оставлю за вами.
Загрузив исходный код, извлеките его в директорию, которую вы случайно не удалите. Я выбрал src в моей домашней директории и могу найти исходники Rust так: C:\users\jeremiah\src\rust-1.7.0 . Снова откройте переменные окружения, создайте новую переменную RUST_SRC_PATH и запишите в неё путь к исходному коду Rust.
Racer
Racer обеспечивает автодополнение кода в инструментах разработки программного обеспечения. Он может быть весьма полезным, если вы изучаете язык или разбираете код, пытаясь понять, какие параметры принимает функция. Если вы добавили .cargo\bin в PATH и задали переменную окружения RUST_SRC_PATH , установить Racer будет очень легко. Просто запустите cargo install racer и подождите.
rustfmt
rustfmt форматирует код на Rust. Он вам здорово поможет в работе. Не то чтобы вы не могли сами правильно форматировать код, но эта программа следит за соблюдением единого стиля. Спорить о форматировании кода не стоит. Избегайте этого.
Редактор
Лично я использую Visual Studio Code. Я слышал, что Sublime Text с недавних пор хорошо работает с Rust. Также этот язык поддерживается в Atom и других редакторах.
На странице Racer вы можете найти ссылки на инструкции по работе с разными редакторами. В Visual Studio Code я установил только расширения Rusty Code и vsc-rustfmt.
Примечание переводчика: мне Visual Studio Code не очень понравилась, так что было много надежд на расширение VisualRust для Visual Studio. К сожалению, на данный момент это расширение не поддерживает Cargo.
Как-то сложно!
Вам может показаться, что этот путь слишком длинный, но пройти его довольно легко и, честно говоря, это быстрее, чем ждать, пока установится Visual Studio и 90 других зависимостей.
Rust is a powerful programming language, often used for systems programming where performance and correctness are high priorities. If you are new to Rust and want to learn more, The Rust Programming Language online book is a great place to start. This topic goes into detail about setting up and using Rust within Visual Studio Code, with the rust-analyzer extension.
Installation
1. Install Rust
First you will need to have the Rust toolset installed on your machine. Rust is installed via the rustup installer, which supports installation on Windows, macOS, and Linux. Follow the rustup installation guidance for your platform, taking care to install any extra tools required to build and run Rust programs.
Note: As with installing any new toolset on your machine, you'll want to make sure to restart your terminal/Command Prompt and VS Code instances to use the updated toolset location in your platform's PATH variable.
2. Install the rust-analyzer extension
You can find and install the rust-analyzer extension from within VS Code via the Extensions view ( ⇧⌘X (Windows, Linux Ctrl+Shift+X ) ) and searching for 'rust-analyzer'. You should install the Release Version.
Check your installation
After installing Rust, you can check that everything is installed correctly by opening a new terminal/Command Prompt, and typing:
which will output the version of the Rust compiler. If you run into problems, you can consult the Rust installation guide.
You can keep your Rust installation up to date with the latest version by running:
There are new stable versions of Rust published very 6 weeks so this is a good habit.
Local Rust documentation
When you install Rust, you also get the full Rust documentation set locally installed on your machine, which you can review by typing rustup doc . The Rust documentation, including The Rust Programming Language and The Cargo Book, will open in your local browser so you can continue your Rust journey while offline.
Hello World
Cargo
When you install Rust with rustup, the toolset includes the rustc compiler, the rustfmt source code formatter, and the clippy Rust linter. You also get Cargo, the Rust package manager, to help download Rust dependencies and build and run Rust programs. You'll find that you end up using cargo for just about everything when working with Rust.
Cargo new
A good way to create your first Rust program is to use Cargo to scaffold a new project by typing cargo new . This will create a simple Hello World program along with a default Cargo.tml dependency file. You pass cargo new the folder where you'd like to create the project.
Let's create Hello World. Navigate to a folder where you'd like to create your project and type:
To open your new project in VS Code, navigate into the new folder and launch VS Code via code . :
Note: Enable Workspace Trust for the new folder as you are the author. You can enable Workspace Trust for your entire project folder parent to avoid being prompted when you create new projects by checking the option to Trust the authors of all the files in parent folder 'my_projects`.
cargo new creates a simple Hello World project with a main.rs source code file and Cargo.toml Cargo manifest file.
main.rs has the program's entry function main() and prints "Hello, world!" to the console using println! .
This simple Hello World program doesn't have any dependencies but you would add Rust package (crate) references under [dependencies] .
Cargo build
Cargo can be used to build your Rust project. Open a new VS Code integrated terminal ( ⌃⇧` (Windows, Linux Ctrl+Shift+` ) ) and type cargo build .
You will now have target\debug folder with build output include an executable called hello_world.exe .
Running Hello World
Cargo can also be used to run your Rust project via cargo run .
You can also run hello_world.exe manually in the terminal by typing .\target\debug\hello_world .
IntelliSense
IntelliSense features are provided by the Rust language server, rust-analyzer, which provides detailed code information and smart suggestions.
When you first open a Rust project, you can watch rust-analyzer's progress in the lower left of the Status bar. You want to wait until rust-analyzer has completely reviewed your project to get the full power of the language server.
Inlay hints
One of the first things you may notice is rust-analyzer providing inlay hints to show inferred types, return values, named parameters in light text in the editor.
While inlay hints can be helpful for understanding your code, you can also disable the feature via the Editor > Inlay Hints: Enabled setting ( editor.inlayHints.enabled ) or use the Rust Analyzer: Toggle Inlay Hints command to hide or display this extra information.
Hover information
Hovering on any variable, function, type, or keyword will give you information on that item such as documentation, signature, etc. You can also jump to the type definition in your own code or the standard Rust libraries.
Auto completions
As you type in a Rust file, IntelliSense provides you with suggested completions and parameter hints.
Tip: Use ⌃Space (Windows, Linux Ctrl+Space ) to trigger the suggestions manually.
Semantic syntax highlighting
rust-analyzer is able to use semantic syntax highlighting and styling due to it's rich understanding of a project source code. For example, you may have noticed that mutable variables are underlined in the editor.
Being able to quickly tell which Rust variables are mutable or not can help your understanding of source code but you can also change the styling with VS Code editor.semanticTokenColorCustomizations setting in your user settings.
In settings.json , you would add:
You can learn more about rust-analyzer's semantic syntax customizations in the Editor features section of the rust-analyzer documentation.
Code navigation
Code navigation features are available in the context menu in the editor.
- Go To Definition F12 - Go to the source code of the type definition.
- Peek Definition ⌥F12 (Windows Alt+F12 , Linux Ctrl+Shift+F10 ) - Bring up a Peek window with the type definition.
- Go to References ⇧F12 (Windows, Linux Shift+F12 ) - Show all references for the type.
- Show Call Hierarchy ⇧⌥H (Windows, Linux Shift+Alt+H ) - Show all calls from or to a function.
You can navigate via symbol search using the Go to Symbol commands from the Command Palette ( ⇧⌘P (Windows, Linux Ctrl+Shift+P ) ).
- Go to Symbol in File - ⇧⌘O (Windows, Linux Ctrl+Shift+O )
- Go to Symbol in Workspace - ⌘T (Windows, Linux Ctrl+T )
Linting
The Rust toolset includes linting, provided by rustc and clippy, to detect issues with your source code.
Quick Fixes
When the linter finds errors and warnings in your source code, rust-analyzer can often provide suggested Quick Fixes (also called Code Actions), which are available via a light bulb hover in the editor. You can quickly open available Quick Fixes via the ⌘. (Windows, Linux Ctrl+. ) .
Refactoring
Due to rust-analyzers semantic understanding of your source code, it can also provide smart renames, across your Rust files. With your cursor on a variable, select Rename Symbol from the context menu, Command Palette, or via F2 .
The rust-analyzer extension also supports other code refactorings and code generation, which the extension calls Assists.
Here are just a few of the refactorings available:
- Convert if statement to guarded return
- Inline variable
- Extract function
- Add return type
- Add import
Formatting
The Rust toolset includes a formatter, rustfmt, which can format your source code to conform to Rust conventions. You can format your Rust file using ⇧⌥F (Windows Shift+Alt+F , Linux Ctrl+Shift+I ) or by running the Format Document command from the Command Palette or the context menu in the editor.
You also have the option to run the formatter on each save (Editor: Format On Save) or paste (Format On Paste) to keep your Rust code properly formatted automatically while you are working.
Debugging
The rust-analyzer extension supports debugging Rust from within VS Code.
Install debugging support
To start debugging, you will first need to install one of two language extension with debugging support:
If you forget to install one of these extensions, rust-analyzer will provide a notification with links to the VS Code Marketplace when you try to start a debug session.
Using Rust Analyzer: Debug
The rust-analyzer extension has basic debugging support via the Rust Analyzer: Debug command available in the Command Palette ( ⇧⌘P (Windows, Linux Ctrl+Shift+P ) ) and the Run|Debug CodeLens in the editor.
Let's debug the Hello World program, we created earlier. First we will set a breakpoint in main.rs .
You'll need to enable the setting Debug: Allow Breakpoints Everywhere, which you can find in the Settings editor ( ⌘, (Windows, Linux Ctrl+, ) ) by searching on 'everywhere`.
Open main.rs and click the left gutter in the editor to set a break point on the println! line. It should display as a red dot.
To start debugging, use either the Rust Analyzer: Debug command or select the Debug CodeLens about main() .
Next steps
This has been a brief overview showing the rust-analyzer extension features within VS Code. For more information, see the details provided in the Rust Analyzer extension User Manual, including how to tune specific VS Code editor configurations.
To stay up to date on the latest features/bug fixes for the rust-analyzer extension, see the CHANGELOG. You can also try out new features and fixes by installing the rust-analyzer Pre-Release Version available in the Extensions view Install dropdown.
If you have any issues or feature requests, feel free to log them in the rust-analyzer extension GitHub repo.
If you'd like to learn more about VS Code, try these topics:
-
- A quick introduction to the basics of the VS Code editor. - Learn about other extensions are available in the Marketplace. - Move quickly through your source code.
Common questions
Linker errors
If you see linker errors such as "error: linker link.exe not found" when you try to build your Rust program, you may be missing the necessary C/C++ toolset. Depending on your platform, you will need to install a toolset with a C/C++ linker to combine the Rust compiler output.
Windows
On Windows, you will need to also install Microsoft C++ Build Tools in order to get the C/C++ linker link.exe . Be sure to select the Desktop Development with C++ when running the Visual Studio installer.
Note: You can use the C++ toolset from Visual Studio Build Tools along with Visual Studio Code to compile, build, and verify any codebase as long as you also have a valid Visual Studio license (either Community, Pro, or Enterprise).
macOS
You may need to install the XCode toolset by running xcode-select --install in a terminal.
Linux
You may need to install the GCC toolset via the build-essential package by running sudo apt-get install build-essential in a terminal.
For further troubleshooting advice, refer to the Rust installation guide.
Читайте также: