NCA Social Media
Aktualisiert:
Autor:
Roland Golla
Grüne Etiketten auf Kisten am Förderband, Container mit Schrift Type Coverage

Was ist Type Coverage?

Type Coverage ist eine PHPStan Erweiterung, die misst, wie viel Prozent der möglichen Typdeklarationen in eurem PHP Code wirklich gesetzt sind. Ihr legt für Rückgabewerte, Parameter, Properties und Konstanten einen Mindestwert fest, und die Pipeline schlägt Alarm, sobald der Code darunter fällt.
Das Paket heißt tomasvotruba/type-coverage und stammt von Tomas Votruba, dem Kopf hinter Rector. Seit Version 2.3 stecken darin auch die Regeln des früheren Pakets Type Perfect. Wer bisher rector/type-perfect genutzt hat, findet alles jetzt an einem Ort.
Inhalt
NCA KI Workshop für Developer

Agentic Coding im Team, nicht nur im Glossar

Ein Tag inhouse mit Benjamin Klein für Developer, Tester und Admins. Context Engineering, Harness, ADRs und zwei Hands on Blöcke mit KI Agenten in eurem Setup.

  1. 1
    Kostenloses Vorgespräch
    Stand, Rollen und Ziele klären
  2. 2
    Workshoptag bei euch
    Praxis am Vormittag, Hands on danach
  3. 3
    Praxistag optional
    Agenten im eigenen Projekt
Benjamin Klein
Benjamin Klein
Senior Consultant
Zum Workshop für Developer arrow_forward

Type Coverage mit NCA richtig einordnen

Softwarequalität ist unser Kerngeschäft. Wir arbeiten täglich mit PHPStan, Psalm und Rector in Symfony Projekten und bauen Quality Gates in GitHub Actions und GitLab CI. Roland Golla beschäftigt sich seit über 20 Jahren mit Testing und Refactoring. Typen sind dabei die erste Verteidigungslinie, noch vor dem ersten Test.
Teams begleiten wir im PHP Consulting, bei der Legacy Modernisierung und beim PHP Refactoring. Wenn KI Agents Code schreiben, setzen die NCA PHP AI Coding Guidelines den Rahmen. Im Glossar findet ihr die Werkzeuge daneben: PHPStan für die statische Analyse und Psalm als zweite Meinung zu Typen.

So rechnet Type Coverage

Die Rechnung ist einfach. Type Coverage zählt alle Stellen, an denen ein Typ stehen könnte, und alle Stellen, an denen wirklich einer steht. Das Verhältnis ist eure Quote.
Code:
          

final class ConferenceFactory
{
    private $talkFactory;

    public function createConference(array $data)
    {
        $talks = $this->talkFactory->create($data);

        return new Conference($talks);
    }
}

Hier gibt es drei mögliche Typen: die Property, den Parameter und den Rückgabewert. Gesetzt ist nur array am Parameter. Das ergibt eine von drei Deklarationen, also rund 33 Prozent.
Code:
          

final class ConferenceFactory
{
    private TalkFactory $talkFactory;

    public function createConference(array $data): Conference
    {
        $talks = $this->talkFactory->create($data);

        return new Conference($talks);
    }
}

Mit zwei kleinen Änderungen steht die Klasse bei 100 Prozent. PHPStan kennt jetzt jeden Typ und findet Tippfehler oder falsche Aufrufe in den nächsten Zeilen.

Type Coverage installieren und einstellen

Installiert wird das Paket als Dev Abhängigkeit.
Code:
          

composer require tomasvotruba/type-coverage --dev

Mit dem PHPStan Extension Installer ist das Paket sofort aktiv. Ohne Installer bindet ihr die Konfiguration selbst ein.
Code:
          

# phpstan.neon
includes:
    - vendor/tomasvotruba/type-coverage/config/extension.neon

Dann setzt ihr pro Art einen Mindestwert in Prozent. Jeder Wert ist einzeln aktiv, ihr könnt also mit nur einer Art starten.
Code:
          

# phpstan.neon
parameters:
    type_coverage:
        return: 50
        param: 35.5
        property: 70
        constant: 85

Wichtig für den Alltag: Die Regeln greifen nur, wenn PHPStan über die vollen Pfade aus der phpstan.neon läuft. Prüft ihr nur einen Unterordner wie src/Controller, bleibt Type Coverage still. So vermeidet das Paket falsche Treffer, wenn ein einzelner Ordner schwächer typisiert ist als der Rest.

Type Coverage Optionen im Überblick

Option Was gezählt wird Hinweis
return Rückgabetypen von Methoden und Funktionen Aufrufer profitieren sofort, weil PHPStan das Ergebnis kennt
param Typen an Parametern Wächst oft mit, wenn Rector Typen aus den Aufrufen ableitet
property Typen an Class Properties Schließt die größte Lücke, weil ungetypte Properties für PHPStan blind sind
constant Typen an Klassenkonstanten Erst ab PHP 8.3 möglich

Type Perfect Regeln stecken jetzt in Type Coverage

Type Perfect war ein eigenes Paket aus dem Rector Umfeld mit strengeren Typregeln für PHPStan. Diese Regeln sind in Type Coverage aufgegangen, rector/type-perfect ist als deprecated markiert. Die Klassen behalten ihren Namespace Rector\TypePerfect. Bestehende Ignores und Baselines passen deshalb weiter.
Die Umstellung ist schnell erledigt.
Code:
          

composer remove rector/type-perfect --dev
composer require tomasvotruba/type-coverage --dev

Drei Punkte solltet ihr dabei kennen.
  • PHP 8.4: Type Coverage ab Version 2.3 verlangt PHP 8.4. Type Perfect lief noch ab PHP 8.2.
  • Alles ist opt in: Regeln, die in Type Perfect standardmäßig an waren, schaltet ihr jetzt selbst ein.
  • Eine Regel fehlt: Die Prüfung auf Array Zugriff bei Objekten wurde nicht übernommen.
Behaltet nicht beide Pakete. Sonst lädt PHPStan jede Regel doppelt.
Code:
          

# phpstan.neon
parameters:
    type_perfect:
        no_isset_on_object: true
        no_empty_on_object: true
        no_param_type_removal: true
        no_mixed_property: true
        no_mixed_caller: true
        narrow_param: true
        narrow_return: true

Type Perfect Regeln im Überblick

Option Was die Regel findet Besser so
no_isset_on_object, no_empty_on_object isset oder empty auf Objekten instanceof, damit PHPStan den genauen Typ kennt
no_param_type_removal Implementierungen, die Parametertypen des Interfaces weglassen Die gleiche Signatur wie im Interface
no_mixed_property, no_mixed_caller Zugriffe auf Properties und Methoden ohne bekannten Typ Eine typisierte Property, damit Tippfehler auffallen
narrow_param, narrow_return Zu breite Parameter und Rückgabetypen Der exakte Typ, zum Beispiel float statt mixed

Schritt für Schritt im Legacy Projekt

Type Coverage spielt seine Stärke in alten Projekten aus. Statt tausender PHPStan Fehler auf einmal startet ihr mit der Quote, die der Code heute schafft. Diese Zahl tragt ihr als Mindestwert ein. Ab dann darf es nur noch besser werden.
  1. Quality Gates zuerst. Statische Analyse, Unit Tests, Functional Tests und Cypress E2E laufen in der Pipeline.
  2. Ist Stand messen. PHPStan Bodyscan zeigt die Fehler pro Level, Type Coverage die Quote pro Art.
  3. Werte festschreiben. Die heutige Quote wird zum Mindestwert und steigt in kleinen Schritten.
  4. Typen ergänzen. Gern mit Rector und KI als Helfer, aber jede Änderung geht durchs Review.
  5. Type Perfect zuschalten. Regel für Regel, von no_isset_on_object bis narrow_return.
Das Refactoring läuft dabei bewusst von Hand mit KI Unterstützung. Ein autonomer Agent, der quer durch das Projekt Typen setzt, bringt mehr Risiko als Nutzen. Mit Characterization Tests sichert ihr vorher ab, was der Code heute tut.

Type Coverage als Guardrail für KI Coding

KI Agents schreiben schnell Code. Dabei fehlen oft Typen, oder es landet mixed an Stellen, die eigentlich klar sind. Eine feste Quote in der Pipeline stoppt das automatisch. Der Agent bekommt den PHPStan Fehler zurück und muss nachbessern.
So entsteht ein einfacher Guardrail, der ohne Diskussion im Review greift. Die KI schreibt den Code, die Pipeline hält die Qualität. Wie solche Leitplanken im Team aufgebaut werden, zeigen wir im Vibe Coding Consulting.

Type Coverage, PHPStan Level, Psalm und Rector im Vergleich

Type Coverage arbeitet nicht allein. Es ergänzt die anderen Werkzeuge für Typensicherheit in PHP. Die Tabelle zeigt, wofür jedes davon gedacht ist.

Werkzeuge für Typensicherheit in PHP

Werkzeug Was es leistet Passt, wenn
Type Coverage Misst die Quote gesetzter Typen pro Art und setzt Mindestwerte ihr Typen schrittweise und messbar ausbauen wollt
PHPStan Level Stufen für eine immer strengere statische Analyse ihr die Prüftiefe für den ganzen Code anheben wollt
Psalm Eigene Typanalyse mit Taint Analyse für Sicherheitslücken ihr eine zweite Meinung oder Security Checks braucht
Rector Ergänzt fehlende Typen per Regel im Code ihr viele einfache Fälle auf einmal lösen wollt

This technique is very simple to start even on legacy project.

Tomas Votruba, Maintainer von Rector und Type Coverage – README von type-coverage auf GitHub

Die NCA Erfahrung mit Typen in PHP Projekten

NCA berät Teams, die alte PHP Projekte sicher in die Zukunft bringen wollen. Typen sind dabei oft der erste messbare Schritt. Sie kosten wenig, und jede neue Deklaration hilft der Analyse sofort.
Bei einem PHP Update oder dem PHP 8.6 Upgrade zeigt die Quote, wo der Code wackelt. Für Tests gibt es mit Code Coverage eine eigene Kennzahl, die ihr nicht verwechseln solltet. Toten Code findet ihr mit Unused Public und Class Leak, Laravel Teams greifen zu Larastan. Ist ein Projekt zu alt für Pflege, begleiten wir den Weg heraus als paralleles neues Projekt, etwa mit dem Strangler Fig Pattern.
CYPRESS.IO Ambassador und IT Consultant für QA Engenieering und Qualität in PHP Projekten.
Erreichen Sie unsere PHP Consultant Spezialisten

Wir arbeiten seit über 20 Jahren mit PHP und Symfony. Wir helfen bei PHP Updates und PHP Refactoring und beraten remote zu allen Fragen rund um PHP. Zuerst sichern Tests und statische Analyse den Code ab, dann räumen wir auf. Automatische CI/CD Deployments und eine stabile Docker Umgebung sorgen dafür, dass jede Änderung sicher live geht.

Häufige Fragen zu Type Coverage

Die wichtigsten Antworten zu Type Coverage in PHP: Einrichtung, sinnvolle Werte, der Umzug von Type Perfect und der Einsatz neben PHPStan, Psalm und Rector.
Was ist Type Coverage in PHP 2026?

Type Coverage ist eine PHPStan Erweiterung von Tomas Votruba. Sie misst den Anteil gesetzter Typdeklarationen an allen möglichen Stellen im Code, getrennt nach Rückgabewerten, Parametern, Properties und Konstanten. Ihr legt pro Art einen Mindestwert fest. Fällt der Code darunter, meldet PHPStan einen Fehler, und die Pipeline bleibt rot. So wächst die Typensicherheit messbar und Schritt für Schritt.

Was ist mit Type Perfect 2026 passiert?

Type Perfect ist als deprecated markiert. Die Regeln wurden mit Version 2.3 in Type Coverage übernommen. Ihr entfernt rector/type-perfect aus der composer.json und installiert tomasvotruba/type-coverage. Die Regeln behalten ihren alten Namespace, deshalb passen Ignores und Baselines weiter. Nur die Prüfung auf Array Zugriff bei Objekten wurde nicht übernommen.

Welche PHP Version braucht Type Coverage 2026?

Type Coverage ab Version 2.3, also mit den Type Perfect Regeln, verlangt PHP 8.4. Type Perfect lief noch ab PHP 8.2. Projekte auf älteren PHP Versionen bleiben vorerst bei einer älteren Type Coverage Version oder planen zuerst das PHP Update. Das lohnt sich ohnehin, weil alte PHP Versionen keine Sicherheitsupdates mehr bekommen.

Welche Type Coverage Werte sind 2026 sinnvoll?

Startet mit dem Wert, den euer Code heute erreicht, und tragt ihn als Mindestwert ein. Dann hebt ihr die Quote in kleinen Schritten an, etwa bei jedem größeren Ticket. Ein starrer Zielwert von außen bringt wenig. Wichtig ist, dass die Zahl nie sinkt und neuer Code von Anfang an vollständig typisiert ist.

Hilft Type Coverage 2026 bei KI generiertem Code?

Ja. KI Agents lassen gern Typen weg oder greifen zu mixed. Eine feste Quote in der Pipeline fängt das ohne Diskussion ab. Der Agent bekommt den PHPStan Fehler zurück und muss nachbessern. Zusammen mit den Type Perfect Regeln entsteht so ein einfacher Guardrail, der auch bei hohem Tempo die Qualität hält.

Wie installiere ich Type Coverage?

Ihr installiert das Paket mit composer require tomasvotruba/type-coverage --dev. Mit dem PHPStan Extension Installer ist es sofort aktiv. Ohne Installer bindet ihr die Datei config/extension.neon aus dem Paket in eure phpstan.neon ein. Danach setzt ihr unter type_coverage die Mindestwerte für return, param, property und constant.

Warum meldet Type Coverage bei einzelnen Ordnern nichts?

Das ist Absicht. Type Coverage greift nur, wenn PHPStan über die vollen Pfade aus der phpstan.neon läuft. Ein einzelner Ordner kann schwächer typisiert sein als das Projekt im Schnitt. Würde das Paket dort anschlagen, gingen andere Fehler in der Ausgabe unter. Startet PHPStan also ohne Pfadangabe, wenn ihr die Quote prüfen wollt.

Was ist der Unterschied zwischen Type Coverage und Code Coverage?

Code Coverage misst, welcher Code bei euren Tests läuft. Type Coverage misst, wie viele Typdeklarationen im Code stehen. Beide Zahlen sagen etwas anderes. Hohe Code Coverage schützt nicht vor fehlenden Typen, und volle Typen ersetzen keinen Test. In einem gesunden Projekt beobachtet ihr beide Werte getrennt.

Ersetzt Type Coverage ein höheres PHPStan Level?

Nein. PHPStan Level bestimmen, wie streng die Analyse prüft. Type Coverage misst, wie viele Typen überhaupt da sind. Beides ergänzt sich gut. Mehr Typen machen höhere Level erst erreichbar, weil PHPStan dann mehr über den Code weiß. Oft lohnt es sich, zuerst die Quote und danach das Level zu heben.

Welche Type Perfect Regel sollte ich zuerst einschalten?

Am einfachsten sind no_isset_on_object und no_empty_on_object. Sie ersetzen isset und empty auf Objekten durch instanceof, damit PHPStan den genauen Typ kennt. Danach folgen no_param_type_removal, die Regeln gegen mixed Zugriffe und zum Schluss narrow_param und narrow_return. In dieser Reihenfolge stehen die Regeln auch in der Dokumentation.

Kann Rector fehlende Typen automatisch ergänzen?

Rector bringt Regeln mit, die Typen aus Aufrufen und Rückgaben ableiten. Das spart viel Handarbeit. Trotzdem gehört jede Änderung ins Review, weil ein falsch abgeleiteter Typ zur Laufzeit knallen kann. Wir setzen auf Refactoring von Hand mit KI und Rector als Helfer, abgesichert durch Tests in der Pipeline.

Lohnt sich Type Coverage auch in Laravel Projekten?

Ja. Type Coverage ist eine normale PHPStan Erweiterung und funktioniert unabhängig vom Framework. In Laravel Projekten läuft PHPStan meist über Larastan, das Eloquent und Facades versteht. Type Coverage ergänzt das um eine klare Quote. So seht ihr auch in großen Laravel Codebasen, ob die Typensicherheit wächst.