Décompiler [OverloadResolutionPriority] : une décision de compilation figée dans l'appel
L'attribut OverloadResolutionPriority oriente la résolution de surcharge, mais ne marque que la définition de la méthode, jamais l'appel. Voici comment Glass.NET lit les deux côtés.
C# 13 a ajouté un outil petit et tranchant aux règles de résolution de surcharge : [OverloadResolutionPriority]. On le place sur un membre d’un groupe de surcharges et on lui donne un entier ; parmi les candidats que le compilateur juge déjà applicables, celui de plus haute priorité l’emporte, en supplantant les critères habituels de « meilleure surcharge ». Le BCL de .NET 9 l’utilise pour que les surcharges basées sur span prennent discrètement le pas sur leurs aînées basées sur tableaux et chaînes, de sorte que les sites d’appel existants se lient au chemin le plus rapide à la simple recompilation — sans changement de code source et sans erreur d’ambiguïté.
C’est aussi un problème de décompilation réellement intéressant, et pour la raison inverse de la plupart des constructions dont nous avons parlé. Le mot-clé field est invisible dans les métadonnées et visible seulement dans l’IL de l’accesseur. [OverloadResolutionPriority] est l’inverse : il est parfaitement visible sur la définition et totalement invisible sur le site d’appel. L’attribut est une directive de compilation dont le seul rôle est d’orienter une décision, et une fois cette décision prise, il ne laisse aucune empreinte sur le code qui en a bénéficié. Cet article montre les métadonnées qu’il écrit, l’IL du site d’appel qu’il n’écrit pas et comment Glass.NET lit chaque côté pour ce qu’il est réellement.
Le groupe de surcharges et l’attribut
Voici la forme que le BCL a adoptée des dizaines de fois dans .NET 9 : une surcharge ancienne qui prend un tableau, et une autre, plus récente et plus rapide, qui prend un ReadOnlySpan<T>. Les deux sont applicables quand on passe un tableau, car il existe une conversion implicite de tableau vers span. Historiquement, la surcharge de tableau l’emportait (c’est une correspondance exacte), de sorte qu’une recompilation ne passait jamais au chemin span. L’attribut renverse cela :
using System;
using System.Runtime.CompilerServices;
public static class Sink
{
[OverloadResolutionPriority(1)]
public static void Add(ReadOnlySpan<int> items) { /* fast path */ }
public static void Add(int[] items) { /* legacy path */ }
}
OverloadResolutionPriorityAttribute vit dans System.Runtime.CompilerServices et se déclare, pour l’essentiel, ainsi :
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor
| AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
public sealed class OverloadResolutionPriorityAttribute : Attribute
{
public OverloadResolutionPriorityAttribute(int priority) => Priority = priority;
public int Priority { get; }
}
La priorité est un int ordinaire ; la valeur par défaut (tout ce qui n’est pas marqué) est 0, et les négatifs réduisent la priorité d’un membre. La règle ne s’applique qu’entre candidats déclarés dans le même type, et seulement après que le compilateur a réduit l’ensemble aux candidats applicables : c’est un départage final, pas un moyen d’appeler quelque chose qui autrement ne se lierait pas.
Ce que l’attribut écrit dans les métadonnées
Appliqué à Add(ReadOnlySpan<int>), l’attribut se compile en un unique enregistrement d’attribut personnalisé rattaché à cette méthode :
.method public hidebysig static void Add(valuetype [System.Runtime]System.ReadOnlySpan`1<int32> items) cil managed
{
.custom instance void [System.Runtime]System.Runtime.CompilerServices.OverloadResolutionPriorityAttribute::.ctor(int32)
= ( 01 00 01 00 00 00 00 00 )
// ...
}
Le blob se décode exactement comme celui de n’importe quel attribut à unique argument int32. Le 01 00 de tête est le prologue fixe. Les quatre octets suivants 01 00 00 00 sont l’argument int32 en little-endian : la valeur 1. Les 00 00 finaux indiquent zéro argument nommé. Rien de spécifique à la construction ici : c’est la même ligne de la table CustomAttribute (0x0C) que produiraient [Obsolete] ou [MethodImpl], ne différant que par sa colonne Type (le .ctor de l’attribut) et son blob Value.
Voilà toute l’empreinte en métadonnées. Glass lit la ligne, résout le token Type en OverloadResolutionPriorityAttribute, décode le blob par rapport à la signature du constructeur et réimprime l’attribut tel quel au-dessus de la méthode. Comme l’attribut est ordinaire, l’aller-retour est propre : ce que vous décompilez est ce que l’auteur a écrit, valeur de priorité comprise. Vous pouvez vérifier vous-même les octets bruts dans le panneau de métadonnées de Glass, qui montre la ligne CustomAttribute avec son token parent et le blob littéral, à côté du C# restitué.
Le site d’appel, où l’attribut ne laisse aucune trace
Passons à la moitié intéressante. Voici du code qui appelle le groupe avec un argument tableau :
Sink.Add(new[] { 1, 2, 3 });
À cause de la priorité, le compilateur lie cela à la surcharge span et insère la conversion implicite de tableau vers span. L’IL émis :
ldc.i4.3
newarr [System.Runtime]System.Int32
dup
ldc.i4.0
ldc.i4.1
stelem.i4
// … stelem.i4 for elements 1 and 2 …
call valuetype [System.Runtime]System.ReadOnlySpan`1<int32>
[System.Runtime]System.ReadOnlySpan`1<int32>::op_Implicit(!0[])
call void Sink::Add(valuetype [System.Runtime]System.ReadOnlySpan`1<int32>)
Comparez-le avec l’IL que vous auriez obtenu avant l’existence de l’attribut, quand la surcharge de tableau l’emportait :
ldc.i4.3
newarr [System.Runtime]System.Int32
dup
ldc.i4.0
ldc.i4.1
stelem.i4
// … stelem.i4 for elements 1 and 2 …
call void Sink::Add(int32[])
Les deux ne diffèrent que par le Sink::Add nommé, plus l’appel op_Implicit dont le chemin span a besoin. Aucun des deux flux d’IL ne contient de référence à OverloadResolutionPriority. L’attribut a fait tout son travail à la compilation : il a incliné la résolution, la résolution a produit un appel lié, et l’appel lié est tout ce dont l’IL se souvient. En lisant l’appelant, un décompilateur ne peut pas dire « une priorité de résolution de surcharge a été consultée ici » : il n’y a rien à lire. Il ne peut que rapporter la méthode effectivement invoquée.
Pourquoi « fidèle à l’IL » est le bon comportement
Il serait tentant d’imaginer un décompilateur qui, voyant un appel à la surcharge span, « simplifierait obligeamment » le op_Implicit et afficherait Sink.Add(new[] { 1, 2, 3 }) comme si de rien n’était. Glass fait exactement cela au niveau du code source — il restitue l’appel C# naturel, parce que c’est ce que l’auteur a écrit — mais il le fait en décompilant l’appel lié qu’il a trouvé, et non en rejouant la résolution de surcharge. Cette distinction compte.
Si Glass re-résolvait la surcharge à partir de zéro en restituant l’appelant, il devrait connaître la priorité pour reproduire la liaison d’origine. Les attributs sont conservés dans les assemblys de référence, donc l’information est généralement là — mais un décompilateur qui dépend de la re-résolution n’est qu’à une mauvaise entrée (un attribut supprimé, un jeu de références qui ne correspond pas) de re-lier silencieusement l’appel à la surcharge de tableau et de produire un code source qui compile vers un IL différent. En décompilant le flux d’instructions que le compilateur a effectivement émis, Glass contourne toute la question : la cible choisie et sa conversion sont des faits dans l’IL, et Glass rapporte des faits. L’attribut de priorité est restitué là où il vit — sur la définition — et le site d’appel est montré comme l’appel concret qu’il est.
Le lire en pratique
Pointez Glass sur l’assembly et deux choses tombent nettement. Sur le type Sink, la surcharge span porte [OverloadResolutionPriority(1)] exactement comme écrit, et le panneau de métadonnées montre la ligne CustomAttribute sous-jacente si vous voulez voir le blob. Sur n’importe quel appelant, vous voyez l’appel ordinaire et lié — à la surcharge span, avec la conversion de tableau vers span en ligne — et aucune mention de la priorité, car aucune n’a été émise. Depuis la CLI, la même division apparaît dans le code source exporté :
glass decompile Sink.dll --type Sink --member Add
glass decompile App.dll --type Program --member Main
La première imprime l’attribut sur la définition ; la seconde imprime l’appel résolu sans aucun attribut à proximité. Cette asymétrie n’est pas un défaut de l’outil : c’est une image honnête de ce qu’est [OverloadResolutionPriority], une instruction de compilation qui documente une intention sur la définition et laisse le reste du programme n’en rien savoir. Le relire tient moins de la reconstruction que de savoir quelle moitié du binaire regarder, et de faire confiance à l’IL pour l’autre.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.