feat(sca166): Managed-Alias - Vendor-Praefix-Interfaces (IwbX) mit TypeIndex-Negativ-Gate

IsManagedType erkennt Hersteller-Praefix-Interfaces: 'I' + >=1 Klein-
buchstabe + Grossbuchstabe (IwbMainRecord ja; Integer/Int64 nein).
Drop-Sampling-Erkenntnis 2026-07-24: die TES5Edit-Iwb-FPs ueberlebten
nur zufaellig via CFG-Zyklus-Regel statt prinzipiell als managed.

NEGATIV-GATE ueber CtxTypeIndex (nil-sicher): kennt der Index den Namen
als Klasse/Record/Enum, wird die Konvention geblockt - Korpus-Beleg
fuer die Notwendigkeit: IntUserFieldVTable/InstException = class,
ImageCodecInfo u.a. = record (I+klein+Gross trifft reale Werttypen).
tkiAlias bewusst NICHT als managed gewertet (TMyInt = Integer waere
sonst maskiert); die TFileName-Alias-Klasse braucht echte Alias-Ziel-
Aufloesung im Index (Backlog).

REICHWEITEN-GRENZE (dokumentiert): Interfaces liegen im Index als
tkiClass (Parser fuehrt sie als nkClass) - liegt die Interface-Decl im
Scan-Umfang, blockt das Gate auch echte Interfaces. Wirkung daher nur
fuer Fremd-Interfaces ohne mitgescannte Decl = der typische Kunden-
Scan; im Bibliotheks-Selbst-Scan-Korpus byte-identisch (A/B after77<->
after78 BYTE-IDENTISCH, Gate bestanden). Volle Wirkung = tkiInterface-
Unterscheidung via Parser-Marker (eigenes Inkrement, Backlog).

Tests: VendorPrefixInterfaceLocal_NoFinding (FindingsOfFile, Index leer
-> Konvention greift) + VendorPrefixButClass_StillFlagged (Pipeline,
Index kennt die in-unit-Klasse -> Gate blockt, Fund bleibt).

Author: nrodear

SCA.Engine/sources/Detectors/uUninitVar.pas

@@ -329,7 +329,8 @@ function CountWholeWordOccurrences(const NeedleLow, HaystackLow: string;
   end;
 end;
 
-function IsManagedType(const TypeRef: string): Boolean;
+function IsManagedType(const TypeRef: string;
+  AContext: TAnalyzeContext): Boolean;
 var
   T, Orig : string;
   Prefix : string;
@@ -346,6 +347,40 @@ function IsManagedType(const TypeRef: string): Boolean;
   // (I + Kleinbuchstabe) matchen NICHT.
   if (Length(Orig) >= 2) and (Orig[1] = 'I') and CharInSet(Orig[2], ['A'..'Z']) then
     Exit(True);
+  // SCA166-Managed-Alias (Drop-Sampling-Erkenntnis 2026-07-24): Hersteller-
+  // Praefix-Interfaces wie 'IwbMainRecord' (TES5Edit: 'I' + Projektkuerzel
+  // in Kleinbuchstaben + CamelCase-Name) fielen durch die strikte
+  // I-Grossbuchstaben-Konvention - ihre FPs ueberlebten nur zufaellig via
+  // Zyklus-Regel des CFG-Postfilters. Muster: 'I' + >=1 Kleinbuchstabe +
+  // Grossbuchstabe ('IwbX' ja; 'Integer'/'Int64' nein - nach deren
+  // Kleinlauf folgt kein Grossbuchstabe). NEGATIV-GATE ueber den Cross-
+  // Unit-TypeIndex: kennt er den Namen als Klasse/Record/Enum, ist es
+  // KEIN Interface -> nicht managed (eine uninitialisiert gelesene
+  // KLASSEN-Referenz ist ein echter Bug und bleibt Fund). Korpus-Beleg
+  // fuer die Strenge: IntUserFieldVTable/InstException = class,
+  // ImageCodecInfo & Co. = record - das Muster trifft reale Werttypen.
+  // REICHWEITEN-GRENZE (byte-identisch im Selbst-Scan-Korpus, A/B
+  // after77/78): der Parser legt Interfaces als nkClass ab, der Index
+  // fuehrt sie als tkiClass - liegt die Interface-DECL im Scan-Umfang,
+  // blockt das Gate auch echte Interfaces. Die Konvention wirkt damit
+  // fuer FREMD-Interfaces ohne mitgescannte Decl (der typische Kunden-
+  // Scan). Volle Wirkung braeuchte tkiInterface im Index (Parser-
+  // Marker an nkClass = eigenes risikobehaftetes Inkrement, Backlog).
+  if (Length(Orig) >= 3) and (Orig[1] = 'I') and CharInSet(Orig[2], ['a'..'z']) then
+  begin
+    var i := 2;
+    while (i <= Length(Orig)) and CharInSet(Orig[i], ['a'..'z']) do
+      Inc(i);
+    if (i <= Length(Orig)) and CharInSet(Orig[i], ['A'..'Z']) then
+    begin
+      // CtxTypeIndex kann nil sein (Tests/Single-File ohne Kontext) -
+      // dann greift die Konvention ohne Gate (gleiche Vertrauensstufe
+      // wie die bestehende I-Grossbuchstaben-Regel).
+      var TI := CtxTypeIndex(AContext);
+      if (TI = nil) or (TI.TypeKindOf(T) in [tkiUnknown, tkiAlias]) then
+        Exit(True);
+    end;
+  end;
 end;
 
 function IsNoInitRecordType(const TypeRef: string): Boolean;
@@ -1982,7 +2017,7 @@ class procedure TUninitVarDetector.AnalyzeMethod(MethodNode: TAstNode;
       VarRec.FirstWriteLine := 0;
       VarRec.FirstReadLine  := 0;
       VarRec.RefCount       := 0;
-      VarRec.IsManaged      := IsManagedType(LV.TypeRef);
+      VarRec.IsManaged      := IsManagedType(LV.TypeRef, AContext);
       // Duplikate (same name in nested-scope - selten, defensive skip)
       if VarMap.ContainsKey(VarRec.NameLow) then Continue;
       VarMap.Add(VarRec.NameLow, VarList.Count);

StaticCodeAnalyserForm/tests/uTestUninitVar.pas

@@ -126,6 +126,9 @@   TTestUninitVar = class
     [Test] procedure CfgUnguardedLoopConditionRead_StillFlagged;  // bson-Muster: Regel B braucht Guard
     [Test] procedure DeclInitializedLocal_NoFinding;              // FPC 'V: Integer = 1' = Write
     [Test] procedure DeclCommentEquals_StillFlagged;              // '=' im Kommentar != Initializer
+    // Managed-Alias 2026-07-24: Hersteller-Praefix-Interfaces (IwbX)
+    [Test] procedure VendorPrefixInterfaceLocal_NoFinding;
+    [Test] procedure VendorPrefixButClass_StillFlagged;
   end;
 
 implementation
@@ -2179,6 +2182,65 @@ procedure TTestUninitVar.DeclCommentEquals_StillFlagged;
   finally F.Free; end;
 end;
 
+procedure TTestUninitVar.VendorPrefixInterfaceLocal_NoFinding;
+// Managed-Alias: 'IwbThing' (I + Kleinpraefix + CamelCase) ist nach Delphi-
+// Konvention ein Interface -> compiler-nil-initialisiert -> nie ein echter
+// uninit-Read. Vor dem Fix fiel das Muster durch die I-GROSSbuchstaben-
+// Konvention (Drop-Sampling TES5Edit: IwbGroupRecord & Co.).
+const
+  SRC =
+    'unit u;'#13#10 +
+    'interface'#13#10 +
+    'implementation'#13#10 +
+    'procedure P;'#13#10 +
+    'var G: IwbThing; X: Integer;'#13#10 +
+    'begin'#13#10 +
+    '  X := G.Count;'#13#10 +
+    '  WriteLn(X);'#13#10 +
+    'end;'#13#10 +
+    'end.'#13#10;
+var
+  F : TObjectList<TLeakFinding>;
+begin
+  RunOn(SRC, F);
+  try
+    Assert.AreEqual<Integer>(0, CountKind(F, fkUninitVar),
+      'Hersteller-Praefix-Interface ist managed -> kein uninit-Fund');
+  finally F.Free; end;
+end;
+
+procedure TTestUninitVar.VendorPrefixButClass_StillFlagged;
+// TP-Gegenprobe (Negativ-Gate): der Name sieht aus wie ein Vendor-
+// Interface, ist laut TypeIndex aber eine KLASSE - uninitialisiert
+// gelesene Klassen-Referenz bleibt ein echter Fund. Voller Pipeline-
+// Weg, damit der Cross-Unit-TypeIndex die in-unit-Klasse kennt.
+const
+  SRC =
+    'unit u;'#13#10 +
+    'interface'#13#10 +
+    'type'#13#10 +
+    '  IwbFake = class'#13#10 +
+    '  public'#13#10 +
+    '    Count: Integer;'#13#10 +
+    '  end;'#13#10 +
+    'implementation'#13#10 +
+    'procedure P;'#13#10 +
+    'var G: IwbFake; X: Integer;'#13#10 +
+    'begin'#13#10 +
+    '  X := G.Count;'#13#10 +
+    '  WriteLn(X);'#13#10 +
+    'end;'#13#10 +
+    'end.'#13#10;
+var
+  F : TObjectList<TLeakFinding>;
+begin
+  F := TFindingHelper.FindingsViaPipeline(SRC);
+  try
+    Assert.IsTrue(CountKind(F, fkUninitVar) >= 1,
+      'TypeIndex kennt IwbFake als Klasse -> Konvention geblockt, Fund bleibt');
+  finally F.Free; end;
+end;
+
 initialization
   TDUnitX.RegisterTestFixture(TTestUninitVar);