Skip to content
← Tous les articles
· Delta1 Labs CollectionsGlass

Comment un décompilateur reconnaît un générateur de collection personnalisé

Une expression de collection qui cible votre propre type doté de [CollectionBuilder] se réduit à un span et un appel de fabrique, sans laisser le moindre crochet dans l'IL. Voici les métadonnées exactes et l'heuristique que Glass.NET emploie pour la reconstituer, et le seul cas qu'elle ne peut trancher.

Les expressions de collection ont été vendues comme du sucre syntaxique, mais le point intéressant est que ce sucre est extensible. Placez [CollectionBuilder] sur un type et [1, 2, 3] en construira une instance. Le hic, pour quiconque lit du code compilé, est que rien dans l’IL émis ne contient de crochet, de liste, ni le moindre indice que l’auteur ait écrit une expression de collection. Ce que vous obtenez, c’est un ReadOnlySpan<T> surgi de nulle part et confié à une méthode de fabrique statique. Récupérer le [...] d’origine à partir de cela est un petit problème de décompilation autonome, et une bonne illustration de la façon dont un décompilateur raisonne à partir d’un attribut plutôt qu’à partir d’un opcode.

La vraie question

Il n’existe pas d’instruction « expression de collection ». Pour un type portant [CollectionBuilder], toute la contribution du compilateur est : matérialiser un span des éléments, puis faire call sur le générateur désigné. La question à laquelle Glass doit répondre n’est donc pas que signifiait cet opcode, mais cet appel précis, avec cette source de span précise, reconstitue-t-il une expression de collection — et si oui, pour quel type cible. Ce raisonnement parcourt les métadonnées à rebours, et non les instructions vers l’avant.

Une collection personnalisée, de bout en bout

Voici un type de collection minimal qui y adhère. L’attribut nomme le type générateur et la méthode ; la méthode doit être statique et prendre un ReadOnlySpan<T>.

using System.Runtime.CompilerServices;

[CollectionBuilder(typeof(RingBuffer), nameof(RingBuffer.Create))]
public sealed class RingBuffer<T>
{
    private readonly T[] _items;
    internal RingBuffer(ReadOnlySpan<T> items) => _items = items.ToArray();
    public int Count => _items.Length;
    public ReadOnlySpan<T>.Enumerator GetEnumerator() => _items.AsSpan().GetEnumerator();
}

public static class RingBuffer
{
    public static RingBuffer<T> Create<T>(ReadOnlySpan<T> items) => new(items);
}

Maintenant un site qui l’utilise avec des éléments constants :

public static RingBuffer<int> Build() => [10, 20, 30];

Le compilateur n’alloue pas de int[], et il n’appelle pas de constructeur de RingBuffer. Pour une charge utile de primitifs entièrement constante, il gare les trois entiers dans un champ de données en lecture seule et construit le span avec RuntimeHelpers.CreateSpan, qui renvoie un span pointant directement vers ce champ — aucune allocation sur le tas :

.method public static class RingBuffer`1<int32> Build() cil managed
{
  ldtoken    field valuetype '<PrivateImplementationDetails>'/'__StaticArrayInitTypeSize=12_Align=4'
             '<PrivateImplementationDetails>'::'3C8CE...A1'
  call       valuetype [System.Runtime]System.ReadOnlySpan`1<!!0>
             [System.Runtime]System.Runtime.CompilerServices.RuntimeHelpers::CreateSpan<int32>(
               valuetype [System.Runtime]System.RuntimeFieldHandle)
  call       class RingBuffer`1<!!0> RingBuffer::Create<int32>(
               valuetype [System.Runtime]System.ReadOnlySpan`1<!!0>)
  ret
}

Trois instructions. Les crochets ont disparu, le nombre d’éléments ne survit que sous la forme du TypeSize=12 d’une structure synthétique (12 octets / sizeof(int) = 3), et le seul mot qui relie tout cela au code source est le Create du call final.

Quand les éléments ne sont pas constants

Remplacez les littéraux par des paramètres et le span ne peut plus provenir d’un champ de données : il n’y a rien de constant à garer. Le compilateur synthétise un type de tampon [InlineArray(3)], l’alloue sur la pile, le remplit via un auxiliaire généré InlineArrayElementRef et en prend un span avec InlineArrayAsReadOnlySpan :

.locals init (valuetype '<>y__InlineArray3`1'<int32> V_0)
ldloca.s   V_0
initobj    valuetype '<>y__InlineArray3`1'<int32>
ldloca.s   V_0
ldc.i4.0
call       !!1& '<PrivateImplementationDetails>'::InlineArrayElementRef<valuetype '<>y__InlineArray3`1'<int32>, int32>(!!0&, int32)
ldarg.0
stind.i4
// … indice 1 depuis ldarg.1, indice 2 depuis ldarg.2 …
ldloca.s   V_0
ldc.i4.3
call       valuetype [System.Runtime]System.ReadOnlySpan`1<!!1> '<PrivateImplementationDetails>'::InlineArrayAsReadOnlySpan<valuetype '<>y__InlineArray3`1'<int32>, int32>(!!0&, int32)
call       class RingBuffer`1<!!0> RingBuffer::Create<int32>(valuetype [System.Runtime]System.ReadOnlySpan`1<!!0>)

Deux sources de span distinctes, la même destination : un call à RingBuffer::Create sur un ReadOnlySpan<int>. Cette destination est l’invariant sur lequel Glass s’ancre.

L’heuristique de récupération

Glass traite la reconstitution comme une confirmation en quatre points. Il ne réécrira un appel en syntaxe de crochets que lorsque tous les points sont vérifiés.

  1. L’appel vise une méthode statique renvoyant un type construit. RingBuffer::Create<int32> renvoie RingBuffer<int>. On note le type de retour C et la méthode M.
  2. La définition de C porte [CollectionBuilder], et elle nomme cette méthode. Glass lit le blob de l’attribut personnalisé sur RingBuffer<T> : un argument System.Type (typeof(RingBuffer)) et une string ("Create"). La méthode appelée doit être cette méthode sur ce type. Une fabrique à la bonne forme mais sans l’attribut qui la désigne n’est pas un générateur.
  3. L’unique argument est un ReadOnlySpan<E> dont le type d’élément E correspond à l’instanciation du générateur.
  4. Le span a été produit par une forme reconnue — soit RuntimeHelpers.CreateSpan<E> sur un champ de <PrivateImplementationDetails>, soit InlineArrayAsReadOnlySpan sur un local <>y__InlineArrayN fraîchement initobj-é. Glass remonte le span jusqu’à ses éléments : le blob RVA décodé en tant que E, ou les valeurs stockées dans chaque emplacement du tableau en ligne.

Ce n’est qu’alors qu’il émet [e0, e1, …], typé vers C. L’attribut de l’étape 2 fait tout : c’est la seule métadonnée qui distingue « une fabrique que quelqu’un a appelée avec un span » de « le générateur que le langage a câblé aux crochets ».

[10, 20, 30]cible : RingBuffer<int>charge constanteRuntimeHelpers.CreateSpancharge variableInlineArrayAsReadOnlySpanReadOnlySpan<int>l'argument invariantcall Create<int>aucun crochet dans l'ILGlass vérifie [CollectionBuilder]l'attribut nomme Create + forme du spancorrespond → reconstitue [10, 20, 30]ne correspond pas → conserve l'appel Create(...)
Les deux sources de span convergent vers un seul appel de générateur ; la récupération dépend de l'attribut et de la forme du span, d'aucun opcode.

Le cas qu’il ne peut trancher

Voici la limite honnête, et elle est réelle plutôt qu’un bogue. Considérez deux sources :

RingBuffer<int> a = [1, 2, 3];
RingBuffer<int> b = RingBuffer.Create([1, 2, 3]);

La première est une expression de collection ciblant RingBuffer<int>. La seconde est un appel explicite à Create, dont l’argument [1, 2, 3] est une expression de collection ciblant le paramètre ReadOnlySpan<int>. Les deux compilent vers un IL identique octet pour octet : le même CreateSpan et le même call RingBuffer::Create. Aucune métadonnée ne les sépare, car au niveau de l’IL il n’y a rien à séparer : le langage définit la première comme une abréviation de la seconde.

Glass tranche l’égalité avec une règle, pas avec une supposition : lorsque le résultat de l’appel au générateur est lui-même la valeur directe d’un emplacement typé vers le type de collection — un initialiseur de local, un return, un argument attendant RingBuffer<int> — il préfère la forme en crochets et affiche [1, 2, 3]. Lorsque le résultat s’écoule vers un endroit qui n’est pas typé vers la collection (il est indexé aussitôt, passé là où un ReadOnlySpan est attendu via une conversion implicite, ou le générateur est une méthode que vous vouliez clairement voir), il laisse RingBuffer.Create([1, 2, 3]) intact. Les deux rendus recompilent vers l’assembly d’origine ; le choix porte sur celui qu’un humain préférerait lire, et le critère de départage est documenté pour que la sortie ne soit jamais silencieusement trompeuse.

Une seconde limite mérite d’être mentionnée : si la méthode génératrice n’est pas générique, ou vit sur un type sans rapport avec la collection, ou si le span provient d’une source que Glass ne reconnaît pas (disons un ReadOnlySpan<T> renvoyé par votre propre auxiliaire), la vérification en quatre points échoue sans danger et vous obtenez le call littéral. C’est la bonne réponse : toute autre chose serait de l’invention.

Utiliser ceci pour lire du code

Lorsque vous ouvrez un assembly dans Glass et voyez un [...] nu sur un type que vous ne reconnaissez pas comme une collection intégrée, c’est votre signal : le type porte [CollectionBuilder], et il existe une fabrique statique à un saut de là qui définit comment il est construit. Sautez à l’attribut (la vue IL montre le blob ; la vue décompilée montre le [CollectionBuilder(typeof(...), "...")] reconstruit sur le type) et vous aurez trouvé le véritable constructeur que les crochets dissimulaient. À l’inverse, lorsque vous voyez un Xyz.Create([...]) explicite, Glass vous indique qu’il n’a pas pu prouver que l’appel externe était du sucre : lisez-le comme une invocation de fabrique délibérée.

À retenir

Une expression de collection dotée de [CollectionBuilder] ne laisse aucune trace syntaxique dans l’IL : juste un span et un appel statique. Glass la reconstitue en raisonnant à partir de l’attribut sur le type cible et de la forme du span, non à partir d’une instruction — et là où deux sources légales s’effondrent vers les mêmes octets, il applique un critère de départage déclaré et réversible plutôt que de feindre savoir laquelle vous avez tapée. Lire les crochets récupérés, et savoir quand ils sont une décision plutôt qu’un fait, fait la différence entre faire confiance à un décompilateur et être surpris par lui.

Essayez Nebula.NET

Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.