Rust in Visual Studio Code

Rust ist eine leistungsstarke Programmiersprache, die häufig für Systemprogrammierung verwendet wird, bei der Leistung und Korrektheit hohe Priorität haben. Wenn Sie neu bei Rust sind und mehr erfahren möchten, ist Das Rust-Programmierhandbuch als Online-Buch ein großartiger Ausgangspunkt. Dieses Thema befasst sich mit der Einrichtung und Verwendung von Rust in Visual Studio Code mit der rust-analyzer-Erweiterung.

Installation

1. Rust installieren

Zuerst müssen Sie das Rust-Toolset auf Ihrem Computer installiert haben. Rust wird über das rustup-Installationsprogramm installiert, das die Installation unter Windows, macOS und Linux unterstützt. Befolgen Sie die Anweisungen zur rustup-Installation für Ihre Plattform und stellen Sie sicher, dass Sie alle zusätzlichen Tools installieren, die zum Erstellen und Ausführen von Rust-Programmen erforderlich sind.

2. Die rust-analyzer-Erweiterung installieren

Sie können die rust-analyzer-Erweiterung über VS Code in der Erweiterungsansicht (⇧⌘X (Windows, Linux Ctrl+Shift+X)) finden und installieren, indem Sie nach 'rust-analyzer' suchen. Sie sollten die Release-Version installieren.

Wir werden viele der rust-analyzer-Funktionen in diesem Thema besprechen, aber Sie können auch die Dokumentation der Erweiterung unter https://rust-analyzer.github.io einsehen.

Installation überprüfen

Nach der Installation von Rust können Sie überprüfen, ob alles korrekt installiert ist, indem Sie ein neues Terminal/eine Eingabeaufforderung öffnen und Folgendes eingeben:

rustc --version

was die Version des Rust-Compilers ausgibt. Wenn Sie weitere Details wünschen, können Sie das Argument --verbose hinzufügen. Wenn Sie auf Probleme stoßen, können Sie die Installationsanleitung von Rust konsultieren.

Sie können Ihre Rust-Installation mit der neuesten Version auf dem neuesten Stand halten, indem Sie Folgendes ausführen:

rustup update

Es werden alle 6 Wochen neue stabile Versionen von Rust veröffentlicht, daher ist dies eine gute Gewohnheit.

Lokale Rust-Dokumentation

Wenn Sie Rust installieren, erhalten Sie auch den vollständigen Satz an Rust-Dokumentationen lokal auf Ihrem Computer installiert, den Sie durch Eingabe von rustup doc überprüfen können. Die Rust-Dokumentation, einschließlich Das Rust-Programmierhandbuch und Das Cargo-Handbuch, wird in Ihrem lokalen Browser geöffnet, sodass Sie Ihre Rust-Reise auch offline fortsetzen können.

Hallo Welt

Cargo

Wenn Sie Rust mit rustup installieren, enthält das Toolset den rustc-Compiler, den rustfmt-Quellcode-Formatter und den clippy Rust-Linter. Sie erhalten auch Cargo, den Rust-Paketmanager, der Ihnen hilft, Rust-Abhängigkeiten herunterzuladen und Rust-Programme zu erstellen und auszuführen. Sie werden feststellen, dass Sie cargo für fast alles verwenden, wenn Sie mit Rust arbeiten.

Cargo new

Eine gute Möglichkeit, Ihr erstes Rust-Programm zu erstellen, ist die Verwendung von Cargo zum Erstellen eines neuen Projekts mit der Eingabe von cargo new. Dies erstellt ein einfaches Hello-World-Programm zusammen mit einer standardmäßigen Cargo.toml-Abhängigkeitsdatei. Sie übergeben cargo new den Ordner, in dem Sie das Projekt erstellen möchten.

Lassen Sie uns Hello World erstellen. Navigieren Sie zu einem Ordner, in dem Sie Ihr Projekt erstellen möchten, und geben Sie ein:

cargo new hello_world

Um Ihr neues Projekt in VS Code zu öffnen, navigieren Sie in den neuen Ordner und starten Sie VS Code mit code .

cd hello_world
code .

cargo new erstellt ein einfaches Hello-World-Projekt mit einer main.rs-Quelldatei und einer Cargo.toml Cargo-Manifestdatei.

src\
    main.rs
.gitignore
Cargo.toml

main.rs enthält die Einstiegsfunktion des Programms main() und gibt "Hello, world!" mit println! auf der Konsole aus.

fn main() {
    println!("Hello, world!");
}

Dieses einfache Hello-World-Programm hat keine Abhängigkeiten, aber Sie würden Rust-Paket (Crate)-Referenzen unter [dependencies] hinzufügen.

Cargo build

Cargo kann zum Erstellen Ihres Rust-Projekts verwendet werden. Öffnen Sie ein neues VS Code integriertes Terminal (⌃⇧` (Windows, Linux Ctrl+Shift+`)) und geben Sie cargo build ein.

cargo build

Sie haben nun einen Ordner target\debug mit Build-Ausgabe, einschließlich einer ausführbaren Datei namens hello_world.exe.

Hello World ausführen

Cargo kann auch zum Ausführen Ihres Rust-Projekts über cargo run verwendet werden.

cargo run

Sie können hello_world.exe auch manuell im Terminal ausführen, indem Sie .\target\debug\hello_world eingeben.

IntelliSense

IntelliSense-Funktionen werden vom Rust-Sprachserver rust-analyzer bereitgestellt, der detaillierte Codeinformationen und intelligente Vorschläge liefert.

Wenn Sie ein Rust-Projekt zum ersten Mal öffnen, können Sie den Fortschritt von rust-analyzer in der unteren linken Ecke der Statusleiste verfolgen. Sie sollten warten, bis rust-analyzer Ihr Projekt vollständig überprüft hat, um die volle Leistung des Sprachservers zu erhalten.

Inline-Hinweise

Eines der ersten Dinge, die Ihnen möglicherweise auffallen, sind die von rust-analyzer bereitgestellten Inlay-Hinweise, die abgeleitete Typen, Rückgabewerte und benannte Parameter in leichter Textform im Editor anzeigen.

Obwohl Inlay-Hinweise hilfreich für das Verständnis Ihres Codes sein können, können Sie die Funktion auch über die Einstellung Editor > Inlay Hints: Enabled (editor.inlayHints.enabled) konfigurieren.

Hover-Informationen

Wenn Sie mit der Maus über eine Variable, Funktion, einen Typ oder ein Schlüsselwort fahren, erhalten Sie Informationen zu diesem Element, wie z. B. Dokumentation, Signatur usw. Sie können auch zur Typdefinition in Ihrem eigenen Code oder in den Standardbibliotheken von Rust springen.

Automatische Vervollständigungen

Während Sie in einer Rust-Datei tippen, bietet Ihnen IntelliSense vorgeschlagene Vervollständigungen und Parameterhinweise.

Semantische Syntaxhervorhebung

rust-analyzer kann semantische Syntaxhervorhebung und -gestaltung nutzen, dank seines tiefen Verständnisses des Quellcodes eines Projekts. Sie haben zum Beispiel vielleicht bemerkt, dass mutable Variablen im Editor unterstrichen sind.

Die Möglichkeit, schnell zu erkennen, welche Rust-Variablen veränderlich sind oder nicht, kann Ihnen helfen, den Quellcode zu verstehen, aber Sie können die Formatierung auch mit der VS Code-Einstellung editor.semanticTokenColorCustomizations in Ihren Benutzereinstellungen Einstellungen ändern.

In settings.json würden Sie hinzufügen:

{
  "editor.semanticTokenColorCustomizations": {
    "rules": {
      "*.mutable": {
        "fontStyle": "", // set to empty string to disable underline, which is the default
      },
    }
  },
}

Sie können mehr über die semantischen Syntaxanpassungen von rust-analyzer im Abschnitt Editor-Funktionen der rust-analyzer-Dokumentation erfahren.

Code-Navigation

Code-Navigationsfunktionen sind im Kontextmenü im Editor verfügbar.

• Gehe zur Definition F12 – Gehe zum Quellcode der Typdefinition.
• Definition anzeigen ⌥F12 (Windows Alt+F12, Linux Ctrl+Shift+F10) – Öffne ein Vorschaufenster mit der Typdefinition.
• Referenzen suchen ⇧F12 (Windows, Linux Shift+F12) – Zeige alle Referenzen für den Typ an.
• Aufrufhierarchie anzeigen ⇧⌥H (Windows, Linux Shift+Alt+H) – Zeige alle Aufrufe von oder an eine Funktion an.

Sie können über die Symbolsuche navigieren, indem Sie die Befehle Symbol aufrufen aus der Befehlspalette (⇧⌘P (Windows, Linux Ctrl+Shift+P)) verwenden.

• Symbol in Datei suchen - ⇧⌘O (Windows, Linux Ctrl+Shift+O)
• Symbol im Workspace suchen - ⌘T (Windows, Linux Ctrl+T)

Linting

Das Rust-Toolset umfasst Linting, bereitgestellt von rustc und clippy, um Probleme in Ihrem Quellcode zu erkennen.

Der standardmäßig aktivierte rustc-Linter erkennt grundlegende Rust-Fehler. Sie können jedoch clippy verwenden, um mehr Lints zu erhalten. Um die clippy-Integration in rust-analyzer zu aktivieren, ändern Sie die Einstellung Rust-analyzer > Check: Command (rust-analyzer.check.command) auf clippy anstelle des Standardwerts check. Die rust-analyzer-Erweiterung führt dann cargo clippy aus, wenn Sie eine Datei speichern, und zeigt clippy-Warnungen und -Fehler direkt im Editor und in der Problemansicht an.

Schnelle Korrekturen

Wenn der Linter Fehler und Warnungen in Ihrem Quellcode findet, kann rust-analyzer oft vorgeschlagene Schnelle Korrekturen (auch Code Actions genannt) anbieten, die über eine Glühbirne im Editor verfügbar sind. Sie können verfügbare Schnelle Korrekturen schnell über ⌘. (Windows, Linux Ctrl+.) öffnen.

Zusätzlich ist die Einstellung Code Action Widget: Nearby Quick Fixes einbeziehen (editor.codeActionWidget.includeNearbyQuickFixes) standardmäßig aktiviert, was den nächstgelegenen Quick Fix in einer Zeile von ⌘. (Windows, Linux Ctrl+.) (Befehls-ID editor.action.quickFix) aktiviert, unabhängig davon, wo sich Ihr Cursor in dieser Zeile befindet.

Der Befehl hebt den Quellcode hervor, der mit Quick Fixes refactored oder behoben wird. Normale Codeaktionen und nicht-fixierende Refactorings können weiterhin an der Cursorposition aktiviert werden.

Refactoring

Aufgrund des semantischen Verständnisses Ihres Quellcodes durch rust-analyzer kann es auch intelligente Umbenennungen über Ihre Rust-Dateien hinweg durchführen. Wenn sich Ihr Cursor auf einer Variablen befindet, wählen Sie Symbol umbenennen aus dem Kontextmenü, der Befehlspalette oder über F2.

Die rust-analyzer-Erweiterung unterstützt auch andere Code-Refactorings und Code-Generierungen, die die Erweiterung Assists nennt.

Hier sind nur einige der verfügbaren Refactorings:

• If-Anweisung in geschützten Rückgabewert konvertieren
• Variable inline setzen
• Funktion extrahieren
• Rückgabetyp hinzufügen
• Import hinzufügen

Formatierung

Das Rust-Toolset enthält einen Formatter, rustfmt, der Ihren Quellcode gemäß den Rust-Konventionen formatieren kann. Sie können Ihre Rust-Datei mit ⇧⌥F (Windows Shift+Alt+F, Linux Ctrl+Shift+I) formatieren oder den Befehl Dokument formatieren aus der Befehlspalette oder dem Kontextmenü im Editor ausführen.

Sie haben auch die Möglichkeit, den Formatter bei jedem Speichern (Editor: Format On Save) oder Einfügen (Format On Paste) auszuführen, um Ihren Rust-Code während der Arbeit automatisch richtig formatieren zu lassen.

Debugging

Die rust-analyzer-Erweiterung unterstützt das Debugging von Rust direkt in VS Code.

Debugging-Unterstützung installieren

Um mit dem Debugging zu beginnen, müssen Sie zuerst eine der beiden Spracherweiterungen mit Debugging-Unterstützung installieren:

• Microsoft C++ (ms-vscode.cpptools) – unter Windows
• CodeLLDB (vadimcn.vscode-lldb) – unter macOS/Linux

Wenn Sie vergessen, eine dieser Erweiterungen zu installieren, zeigt rust-analyzer eine Benachrichtigung mit Links zum VS Code Marketplace an, wenn Sie versuchen, eine Debug-Sitzung zu starten.

Rust Analyzer verwenden: Debuggen

Die rust-analyzer-Erweiterung bietet grundlegende Debugging-Unterstützung über den Befehl Rust Analyzer: Debug, der in der Befehlspalette (⇧⌘P (Windows, Linux Ctrl+Shift+P)) und dem Run|Debug CodeLens im Editor verfügbar ist.

Lassen Sie uns das Hello-World-Programm debuggen, das wir zuvor erstellt haben. Zuerst setzen wir einen Breakpoint in main.rs.

1. Sie müssen die Einstellung Debug: Allow Breakpoints Everywhere aktivieren, die Sie im Einstellungen-Editor (⌘, (Windows, Linux Ctrl+,)) finden, indem Sie nach 'everywhere' suchen.

   

2. Öffnen Sie main.rs und klicken Sie in die linke Spalte des Editors, um einen Breakpoint in der Zeile println! zu setzen. Er sollte als roter Punkt angezeigt werden.

   

3. Um mit dem Debugging zu beginnen, verwenden Sie entweder den Befehl Rust Analyzer: Debug oder wählen Sie den Debug CodeLens über main() aus.

   

Nächste Schritte

Dies war ein kurzer Überblick über die Funktionen der rust-analyzer-Erweiterung in VS Code. Weitere Informationen finden Sie in den Details des Benutzerhandbuchs der Rust Analyzer-Erweiterung, einschließlich der Konfiguration spezifischer VS Code-Editor-Einstellungen.

Um über die neuesten Funktionen/Fehlerbehebungen für die rust-analyzer-Erweiterung auf dem Laufenden zu bleiben, siehe das CHANGELOG. Sie können auch neue Funktionen und Korrekturen ausprobieren, indem Sie die Pre-Release-Version von rust-analyzer installieren, die im Dropdown-Menü Installieren der Erweiterungsansicht verfügbar ist.

Wenn Sie Probleme oder Feature-Anfragen haben, können Sie diese gerne in GitHub-Repository der rust-analyzer-Erweiterung melden.

Wenn Sie mehr über VS Code erfahren möchten, probieren Sie diese Themen aus:

• Grundlegende Bearbeitung – Eine kurze Einführung in die Grundlagen des VS Code-Editors.
• Erweiterung installieren – Erfahren Sie mehr über andere Erweiterungen, die im Marketplace verfügbar sind.
• Code-Navigation – Schnelles Bewegen durch Ihren Quellcode.

Häufig gestellte Fragen

Linker-Fehler

Wenn Sie beim Erstellen Ihres Rust-Programms Linker-Fehler wie "error: linker link.exe not found" sehen, fehlt Ihnen möglicherweise das notwendige C/C++-Toolset. Je nach Plattform müssen Sie ein Toolset mit einem C/C++-Linker installieren, um die Ausgabe des Rust-Compilers zu kombinieren.

Windows

Unter Windows müssen Sie außerdem Microsoft C++ Build Tools installieren, um den C/C++-Linker link.exe zu erhalten. Stellen Sie sicher, dass Sie Desktopentwicklung mit C++ auswählen, wenn Sie das Visual Studio-Installationsprogramm ausführen.

macOS

Möglicherweise müssen Sie das XCode-Toolset installieren, indem Sie xcode-select --install in einem Terminal ausführen.

Linux

Möglicherweise müssen Sie das GCC-Toolset über das Paket build-essential installieren, indem Sie sudo apt-get install build-essential in einem Terminal ausführen.

Weitere Ratschläge zur Fehlerbehebung finden Sie in der Rust-Installationsanleitung.