Nieuw in Delphi 10.4: Herontworpen Code Inzicht

In 10.4 hebben we code completion en andere functies herwerkt. Het is een van de belangrijkste veranderingen aan de IDE in tien jaar.

Wat bedoelen we met Code Inzicht?

Eerst wat achtergrondinformatie. Als je bekend bent met Code Insight, sla dan maar over...

Code Insight is onze naam voor een reeks productiviteitsfuncties in de editor van de IDE. In dit blogbericht zijn dat de volgende functies:

• Code voltooiing: de vervolgkeuzelijst die voorspelt wat je wilt typen. Verschijnt wanneer u een punt (.) typt na een identificatiecode of wanneer u druk op Ctrl+Spatie.
  
• Parameter Voltooiing: de hint die verschijnt met de parameters voor een methode, inclusief meerdere variaties voor een overloaded methode. Ctrl+Shift+Spatie binnen methode accolades ().
  
• Verklaring zoeken: Klik met de rechtermuisknop op een identifier en klik op Find Declaration, en het zal je naar de plaats brengen waar die methode, variabele, type enz. is gedefinieerd. Je kunt ook Control ingedrukt houden en met je muis over de editor bewegen. De identifiers die van toepassing zijn, veranderen dan in hyperlinks waarop je kunt klikken om hun declaratie te vinden. Bladeren door codes.
• Inzicht in tooltip: Beweeg je muis over een variabele of type en je krijgt er informatie over te zien. Soms bevat dit XMLDoc, en staat bekend als Help Inzicht. (We moeten de namen in ons document verduidelijken).
• Fout inzicht: geeft fouten in je code weer voordat je gaat compileren. Deze staan ook wel bekend als 'red squigglies', de voorkeursterminologie van veel mensen - de rode zigzaglijnen onder je code. Fouten worden ook getoond in de Errors node in de Structuur bekijken.

Deze functies zijn al vele jaren beschikbaar in Delphi. Functies zoals deze zijn een belangrijk voordeel voor je als je een IDE codeert. Met name code completion bespaart veel typewerk, en inzicht in fouten helpt je ervoor te zorgen dat je code werkt voordat je tijd besteedt aan compileren.

Klassieke code inzicht

Naarmate de taal groeide en de tijd verstreek, werkten deze functies niet altijd meer zo goed als we wilden. De technologie was geavanceerd toen het werd geïntroduceerd, maar er zijn zeker verbeteringen die we vandaag de dag kunnen maken.

Het is gebruikelijk om bugrapporten te zien over onechte fouten (d.w.z. fouten die gemeld worden in de editor of in de Structure view terwijl de broncode eigenlijk perfect correcte code is). Of dat de IDE in de hoofddraad werkte, dus niet reageerde op toetsaanslagen terwijl het bezig was om de lijst met voltooide code te tonen. (Je kon alleen op Escape drukken om te annuleren.) Soms, voor gigantische projecten, kon het berekenen van de gegevens voor code voltooiing veel geheugen in beslag nemen in de IDE. Daarnaast waren de functies geïmplementeerd met meerdere code parsers: code completion en error insight hadden elk een ander begrip van de code. En tot slot was code insight uitgeschakeld tijdens het debuggen, dus als je code schreef tijdens het debuggen had je geen hulp bij de productiviteit.

We wilden niet dat dit zo doorging. Onze doelen voor 10.4 waren om:

• Code-inzicht maken asynchroon - dat wil zeggen, draaien op een andere thread of in een ander proces (of beide) zodat de IDE altijd reageert wanneer je typt, zelfs als het werk op de achtergrond doet.
• Het potentieel verminderen of zelfs helemaal verwijderen (je kunt zien waar dit naartoe gaat) geheugengebruik voor het aanvullen van code vanuit de IDE
• Zorg ervoor dat Error Insight altijd juiste resultaten - dat wil zeggen, het zou precies de fouten moeten geven die de compiler zou geven, en correcte code zou geen fouten moeten geven
• Help ons dichter bij een enkele parser voor Delphi-broncode in de IDE, zodat er één enkele bron van waarheid is of één enkel begrip van wat Delphi-code betekent binnen de IDE
• Moderniseren van Delphi's code tooling aanpak om moderne technieken te gebruiken
• En tegelijkertijd een aantal bugs in code voltooiing oplossen
• En voeg ten minste één functie voor het aanvullen van codes toe... Wacht! Voeg twee nieuwe functies voor het aanvullen van codes tegelijk toe!

Dit staat allemaal in Delphi 10.4.

Opgewonden? Wij zijn enthousiast. Dit is een van de grootste en beste veranderingen aan de Delphi IDE in vijftien jaar.

(En maak je geen zorgen - als je dat nodig hebt, is het klassieke code-inzicht er nog steeds, compleet met een paar nieuwe bugfixes, en het kan in 10.4 worden ingeschakeld als je dat wilt).

Code Inzicht Technologie in Delphi 10.4

In 10.4 worden de bovenstaande code-inzicht functies geïmplementeerd met behulp van een 'LSP Server'. Je hebt misschien al van deze technologie gehoord, maar als dat niet zo is, dan verwijst LSP naar het Language Server Protocol, een gestandaardiseerde manier om op code inzicht lijkende functies voor veel talen te implementeren. Een IDE praat met een 'taalserver', wat een kleine hulpapplicatie is die de informatie die de IDE weergeeft berekent en genereert. Dit gebeurt met behulp van een gedefinieerd protocol, en dat is het taalserverprotocol.

Met andere woorden, de IDE praat nu met een helper-app wanneer je iets doet, zoals een project openen of een toetsaanslag typen in je bestand, en de IDE kan het periodiek vragen stellen, zoals: 'Wat zijn de voltooiingsresultaten op deze locatie?'. Die helper-app houdt je code bij en stuurt een antwoord terug op elke vraag, plus eventuele fouten die hij onderweg tegenkwam in de code.

Onze server-app is gebouwd rondom de compiler en gebruikt de compiler als een service om LSP-resultaten te leveren. Dat betekent dat wat de IDE aan u toont, inclusief 'rode kronkelende' fouten, allemaal gegevens zijn die van de compiler zelf komen.

Dit betekent een paar dingen:

• Communicatie met een ander proces is asynchroon. In de IDE wordt het geïmplementeerd in een andere thread. Je kunt blijven typen, zelfs je bestand sluiten of een ander project openen, terwijl de IDE wacht op antwoord op de gevraagde gegevens.
• Het werk wordt gedaan in een ander proces. Dit betekent dat al het geheugengebruik voor het berekenen van resultaten niet meer in de IDE zelf zit. De IDE heeft meer geheugen en de helper-app kan zijn volledige geheugenruimte alleen gebruiken voor het leveren van resultaten.
• Het maakt gebruik van een modern, gestandaardiseerd protocol dat van toepassing is op veel talen
• Wat je op het scherm ziet, is wat de compiler ziet. Dat betekent dat het nauwkeurig zou moeten zijn. Als je code compileert, zie je geen Error Insight fouten; als je daarentegen wel rode kronkelende onderstrepingen ziet in je code of in de Structure view, zal je code niet compileren.
• Je kunt code voltooien tijdens het debuggen.

Dit zijn allemaal heel goede dingen.

Maar genoeg tekst. Laten we eens kijken hoe het er in actie uitziet!

Modern Delphi code-inzicht in actie

Het is moeilijk om responsiviteit te laten zien in een blog. Stel je in deze statische schermafbeeldingen voor dat je aan het typen bent en dat je nooit de wachtende Windows-cursor ziet.

Verbeelding wordt werkelijkheid als we 10.4 uitbrengen!

Inzicht in code tijdens het debuggen

De eerste nieuwe functie is een grote, die niet veel woorden nodig heeft. Je kunt Code Insight gebruiken tijdens het debuggen.

Wil je je app debuggen en tegelijkertijd code typen en code voltooien? Dat kan.

Ja, wat je ziet is correct - dat is code voltooiing en foutinzicht die beide werken terwijl je actief bezig bent met het debuggen van de applicatie.

Resultaten

Het krijgen van code completion is hetzelfde als in 10.3.3, met de uitzondering dat de IDE responsief blijft in 10.4. Maar we hebben nog een nieuwe functie toegevoegd, waarmee je gemakkelijker kunt vinden wat je zoekt via codeaanvulling. In 10.4 zal de code-aanvulling nu meer bruikbare resultaten tonen dan in het verleden - maar met behoud van de items uit 10.3.3 bovenaan de lijst met resultaten.

Hier is de code-aanvulling van 10.3.3, waarbij 'act' wordt getypt achter een VCL TButton-instantie:

Merk op dat 10.3.3 heel weinig resultaten laat zien - slechts één, in feite. Klassieke code voltooiing toont alleen items die beginnen met wat je hebt getypt.

Hier is 10.4 in actie (pun intended) voor dezelfde voltooiing:

In 10.4 geeft codeaanvulling een lijst van alle items die bevatten wat je getypt hebt. Andere IDE's doen dit ook, Visual Studio bijvoorbeeld, maar tot nu toe toont Delphi een beperktere lijst. Dit is handig omdat je zo zoeken tot en met voltooiing.

Stel bijvoorbeeld dat je je herinnert dat een besturingselement een iets-Rect eigenschap heeft, maar je weet niet meer hoe het heet. In 10.3.3 zou je moeten googelen. In 10.4 typ je gewoon 'rect' en je ziet het:

Je kunt je code verkennen door te typen.

Het hebben van meer resultaten is niet altijd wat je zoekt, en je verwacht misschien alleen items die beginnen met wat je uit gewoonte hebt ingetypt. Standaard, en om het gedrag dicht bij wat je vertrouwd bent uit 10.3.3 te houden, sorteren we de aanvullingslijst zo dat alle starts-met identifiers boven alle bevat identifiers worden geplaatst. Met andere woorden, de lijst geeft dezelfde resultaten als 10.3.3maar met extra resultaten toegevoegd. U hoeft deze niet te gebruiken als u dat niet wilt; ze bevinden zich na de items die 10.3.3 u zou hebben getoond.

Als je gedrag wilt zoals bij andere IDE's, waarbij alle resultaten samen worden getoond, dan hebben we een instelling: momenteel een registersleutel, maar we kunnen deze beschikbaar maken als UI. Dat betekent dat als u meer gewend bent aan wat VSCode biedt, u dat ook kunt krijgen.

In 10.4 worden alle items die beginnen met wat je hebt ingetypt bovenaan de lijst gesorteerd. Dit is wat je zou zien in 10.3.3, en is de standaard in 10.4.	In 10.4, sorteren op alleen bereik, zodat alle items die bevatten wat je hebt getypt samen worden getoond. Dit lijkt meer op Visual Studio of andere IDE's en staat standaard uit.

Selectie in de voltooiingslijst

Code voltooiing selecteert automatisch de beste items in de lijst voor je (dus je kunt gewoon op Enter of Spatie of '.' of iets dergelijks drukken om dat item te kiezen en doorgaan met coderen) in de volgende volgorde:

• Een exacte overeenkomst met wat je hebt getypt. Als er geen overeenkomst is:
• Van de items die beginnen met wat je hebt getypt, de kortste identifier. Als er geen begin-met items zijn:
• Van de items die bevatten wat je hebt getypt, is de kortste identifier

Prioriteit geven aan begin-met boven bevat betekent dat de voltooiingslijst automatisch 'Parent' selecteert boven 'SetParent'. Kiezen voor de kortste overeenkomst betekent dat 'Parent' wordt geselecteerd boven 'ParentFont'. (Je kunt dit zien in de bovenstaande schermafbeeldingen.) Over het algemeen vinden we dat dit overeenkomt met wat je waarschijnlijk aan het typen bent. Natuurlijk kun je scrollen en op de pijl-omhoog en pijl-omlaag drukken om alles te selecteren wat je wilt.

Fout inzicht

Merk op dat je in deze schermafbeeldingen live Error Insight kunt zien, dat wordt bijgewerkt terwijl je typt. De gedeeltelijk getypte identifier 'pare', wat geen geldige code is, is correct rood onderstreept. (De onderstreping verdwijnt wanneer je een item selecteert uit de aanvullingslijst). De resultaten van Error Insight komen van de compiler zelf en geven precies weer wat de compiler ziet.

Je zou nooit onjuiste fouten moeten zien in de editor of het Structure deelvenster. Wat je op het scherm ziet, is correct.

Multiproces Architecture

Het volgende is niet belangrijk voor eigenschappen, maar kan je op technisch niveau interesseren.

Ik noemde al dat de LSP server als een apart proces draait, wat een aantal voordelen heeft, waaronder een eigen 4GB geheugenadresruimte voor code-inzicht. Als je kijkt naar 10.4 in Windows Taakbeheer, dan zie je meerdere DelphiLSP processen. De eerste stuurt meerdere agents aan en we hebben één agent die zich richt op het leveren van voltooiing en andere resultaten en één agent die zich richt op het leveren van inzicht in fouten.

Voor zover ik weet zijn wij de enige LSP-server die een multiprocess architectuur gebruikt.

Kwaliteit

Terwijl we dit implementeerden, hebben we ook een aantal problemen gevonden en opgelost die in het verleden van invloed waren op het voltooien van codes.

Volgende stappen

De nieuwe code-aanvulling is anders dan de code-aanvulling in 10.3.3 en eerder. We hebben gewerkt om het zo gelijk mogelijk te maken, inclusief aanpassingen zoals het sorteren van start-met items boven andere, zodat het vertrouwd voor je is als je het voor het eerst gebruikt. We hopen dat je er binnen een paar minuten zo aan gewend bent dat je nooit meer terug wilt naar 10.3.3! Maar we willen dit niet presenteren als precies hetzelfde: je zult verschillen vinden.

De nieuwe Code Insight in Delphi 10.4 lost veel problemen op en maakt het gebruik van de IDE ook voor jou een veel prettigere en responsievere ervaring. En dan hebben we het nog niet eens over de extra resultaten, die erg handig kunnen zijn. We zijn van plan om eraan te blijven werken om de hierboven beschreven doelen te bereiken. In 10.4 hebben wij en onze bètatesters het echter een geweldige toevoeging aan de IDE gevonden.

Daarnaast hebben we zelfs twee nieuwe functies toegevoegd: je code laten verkennen via code completion en Code Insight inclusief code completion en andere Code Insight-functies gebruiken tijdens het debuggen.

We zijn erg enthousiast over deze functie. Asynchroon. Responsieve IDE. Modern protocol. Ondersteuning voor andere talen. Code voltooiing tijdens het debuggen. Het is geweldig spul. We kunnen niet wachten tot je 10.4 hebt en het zelf uitprobeert.

Als je een update-abonnement hebt, is een van de voordelen toegang tot bètaversies van aankomende releases. Er is nog tijd om deel te nemen aan ons bètaprogramma voor 10.4!

Dit is een preview van een aankomende release van RAD Studio. Er kunnen altijd last-minute bugs of wijzigingen zijn. Niets hier is definitief totdat de release officieel beschikbaar is gemaakt.