Perf: Améliorer l'inférence de types pour réduire le dispatch dynamique

[5pilow]

Contexte

Le compilateur LS fait déjà de l'inférence de types et génère du code spécialisé quand les types sont connus. Mais l'inférence actuelle est locale : elle ne propage pas les types à travers les appels de fonction ni les retours.

Problème

function getHP(entity) {  // entity: any
    return getLife(entity)  // return: any
}

var hp = getHP(target)  // hp: any → dispatch dynamique pour toute opération
hp * 2  // → appel runtime mul(Object, Object) au lieu de long * 2

Même si getLife() retourne toujours un entier, le compilateur ne le sait pas.

Solutions proposées

1. Inférence inter-procédurale

Analyser les types de retour des fonctions en examinant tous les chemins de retour :

getLife(entity) → toujours int → getHP retourne int → hp est int

2. Annotations de types optionnelles

Encourager les joueurs à typer leurs fonctions (déjà supporté en LS v2+) :

function getHP(Entity entity) : integer {
    return getLife(entity)
}

Le compilateur peut déjà exploiter ces annotations. L'enjeu est de rendre l'inférence automatique quand elles sont absentes.

3. Spécialisation de fonctions par type d'appel

Générer plusieurs versions d'une fonction selon les types des arguments observés :

// Version spécialisée pour int
long u_double_int(long u_x) { return u_x * 2; }
// Version générique
Object u_double(Object u_x) { return mul(u_x, 2L); }

Impact estimé

• Inférence inter-procédurale : ~15-40% sur du code bien structuré avec des helpers
• Spécialisation : multiplicatif avec les autres optimisations de types
• C'est potentiellement le gain le plus important car il débloque toutes les autres optimisations

Complexité

Haute. C'est un projet significatif mais avec le meilleur ROI potentiel.