Folgender simpler Code:

zusammenfalten · markieren

Delphi-Quellcode:

unit Unit1;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls;

type
  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
  private
    { Private-Deklarationen }
    procedure Foo(S : String);
    procedure Foo2(S : String);
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

{ TForm1 }

procedure TForm1.Button1Click(Sender: TObject);
  begin
    Foo('');
  end;

procedure TForm1.Button2Click(Sender: TObject);
  begin
    Foo2('Hello World');
  end;

procedure TForm1.Foo(S: String);
  begin
    if S = '' then
      begin
        var S_Empty := S;
        ShowMessage(S_Empty);
      end
    else
      begin
        var S_NotEmpty := S;
        ShowMessage(S_NotEmpty);
      end;
  end;

procedure TForm1.Foo2(S: String);
  var S_Empty, S_NotEMpty : String;
  begin
    if S = '' then
      begin
        S_Empty := S;
        ShowMessage(S_Empty);
      end
    else
      begin
        S_NotEmpty := S;
        ShowMessage(S_NotEmpty);
      end;
  end;

end.

Mit einem Strg+Klick auf die Prozeduren Foo und Foo2 gelangt man hierbei immer nur zur Deklaration im interface.
Kommentiert man den Code in der Prozedur Foo aus, landet man wie gewohnt durch Strg+Klick im implementation Abschnitt.
Könnt ihr das bei euch nachvollziehen oder wisst ihr eine Lösung außer "benutze keine Inline Variablen"

Als ich einem größeren Projekt Inlinevariablen bei einer Prozedur in einem ähnlichen Schema eingebaut hab, konnte ich bei der Hälfte der Prozeduren Strg+Klick nicht mehr benutzen. Auch Refactoring war damit in den betroffenen Funktionen lahmgelegt.

Dieses Feature ist im Compiler drin, aber das war es dann auch.

CodeInsight kennt es noch nicht oder nicht richtig und raucht beim Auffinden ab,
womit sowas hier eben nicht mehr funktioniert, ebenso wie Klassenvervollständigung und Dergleichen.

Vielleicht geht es im 10.5 wieder. (oder später, wenn man sich ansieht, wie lange andere Bugs existieren)



Ach ja, du hast nicht auf das alte Code-Insight umgestellt?
> Code Insight-Manager = Delphi (Classic Code insight)
Dort geht sowas garnicht und es wird auch niemals gehen, da dort nichts mehr dran gemacht wird.

Benutzeroberfläche > Editoroptionen > Quelloptionen > Typ=Delphi > Code Insight > Code Insight-Manager = Delphi (Sprachprotokollserver aka LLVM)

Ich benutze den neuen Code-Insight, weil Inline-Variablen da seit 10.4.1 nicht mehr angemeckert werden, aber dann werde ich wohl weiterhin darauf verzichten müssen.

Ist dieses Strg-Click LLVM Problem bereits in QP erfasst?
Falls nicht, kann es bitte erfasst werden? Sonst tut sich da evtl. nie was.
Und ja: LLVM ist an ein paar Stellen noch etwas grün hinter den Ohren, wird
aber meines Wissens nach durch jedes Update besser und ist generell denke ich
die richtige Richtung, nur halt noch nicht weit genug.

Das Problem, dass CodeInsight mit LLVM mit den neuen Features noch nicht geht, gab es schon irgendwo Meldungen.

Und wenn das nicht mehr arbeitet, geht auch alles nicht mehr, was das verwendet.

Zitat von himitsu:

Delphi (Sprachprotokollserver aka LLVM)

Du meinst wohl eher LSP - was für Language Server Protocol steht - LLVM ist eine Compilerarchitektur/-infrastruktur, die in den Delphi Compilern für Android, iOS, Linux und macOS 64bit genutzt wird.

stimmt (darf's nicht mehr ändern ... du warst zu langsam )

LLVM war das für das compiler-zwischencodezeugs (LLVM und Co. können es, da es sich ja compilieren lässt ... wäre zu praktisch, wenn LLVM auch das LSP benutzen würde, dann wäre es immer aktuell)
und LSP das (noch) geheime mache aus Sourcecode eine Baumstruktur (geheim, weil noch keine definition/dokumentation gefunden, damit auch andere das benutzen können)

An LSP ist gar nix geheim und der Link zur Spezifikation befindet sich sogar in dem von mir verlinkten Wikipedia Artikel.
Was geheim ist und auch bleiben wird, ist die Implementierung für Delphi von Embarcadero.
Und ich wage zu behaupten, dass diese auch nicht vollständig ist, so dass du nicht einfach die DelphiLSP.exe nehmen kannst und sie von nem VisualStudioCode ansprechen kannst.

LLVM an sich wird nicht automatisch irgendwas für die Konsumierung über LSP bereitstellen können, da das was über das LSP bereitgestellt wird, eine Aufgabe des Frontends ist. Und dieses ist spezifisch für die Programmiersprache, im Falle von Delphi ist das der Teil eines LLVM basierten Compilers, den Embarcadero entwickelt. Welche Frontend Teile nun in der DelphiLSP.exe werkeln, weiß ich nicht - also ob das die Teile des "classic" Compilers sind, also das, was von dcc32.exe genutzt wird oder das LLVM Frontend und inwiefern die überhaupt irgendeine Gemeinsamkeit haben.
Was Embarcadero "geschenkt" bekommt, sind die Backends für die Zielplattformen, sie müssen sich also nicht um die Codegenerierung für iOS, Android, Linux etc kümmern, sondern das "lediglich" verdrahten (was durchaus mehr Arbeit ist, als man denken mag, vor allem das ganze Runtime Wireup).

Was LSP alles an API anbietet, und was demnach alles in einer Implementierung für die Sprache bereitgestellt werden kann, kann man am Beispiel von clangd sehen.