Cómo un descompilador reconoce un generador de colecciones propio
Una expresión de colección que apunta a tu propio tipo con [CollectionBuilder] se reduce a un span y una llamada de fábrica sin dejar corchetes en el IL. Estos son los metadatos exactos y la heurística que Glass.NET usa para reconstruirla, y el único caso que no puede resolver.
Las expresiones de colección se vendieron como azúcar sintáctico, pero lo interesante es que ese azúcar es extensible. Pon [CollectionBuilder] en un tipo y [1, 2, 3] construirá una instancia de él. El problema, para quien lee código compilado, es que nada en el IL emitido contiene un corchete, una lista ni la menor pista de que el autor escribió una expresión de colección. Lo que obtienes es un ReadOnlySpan<T> surgido de la nada y entregado a un método de fábrica estático. Recuperar el [...] original a partir de eso es un problema de descompilación pequeño y autocontenido, y un buen ejemplo de cómo un descompilador razona a partir de un atributo en lugar de a partir de un opcode.
La pregunta de fondo
No existe una instrucción de «expresión de colección». Para un tipo con [CollectionBuilder], toda la aportación del compilador es: materializar un span de los elementos y luego hacer call al generador designado. Así que la pregunta que Glass debe responder no es qué significaba este opcode, sino ¿esta llamada concreta, con esta fuente de span concreta, reconstituye una expresión de colección?, y si es así, para qué tipo de destino. Ese razonamiento recorre los metadatos hacia atrás, no las instrucciones hacia adelante.
Una colección propia, de principio a fin
Aquí hay un tipo de colección mínimo que se adhiere. El atributo nombra el tipo generador y el método; el método debe ser estático y tomar 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);
}
Ahora un sitio que lo usa con elementos constantes:
public static RingBuffer<int> Build() => [10, 20, 30];
El compilador no asigna un int[], ni llama a un constructor de RingBuffer. Para una carga útil de primitivos totalmente constante, aparca los tres enteros en un campo de datos de solo lectura y construye el span con RuntimeHelpers.CreateSpan, que devuelve un span que apunta directamente a ese campo, sin asignación en el montón:
.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
}
Tres instrucciones. Los corchetes han desaparecido, el número de elementos sobrevive solo como el TypeSize=12 de una estructura sintética (12 bytes / sizeof(int) = 3), y la única palabra que ata todo esto al código fuente es el Create de la call final.
Cuando los elementos no son constantes
Cambia los literales por parámetros y el span ya no puede venir de un campo de datos: no hay nada constante que aparcar. El compilador sintetiza un tipo de búfer [InlineArray(3)], lo asigna en la pila, lo rellena mediante un auxiliar generado InlineArrayElementRef y toma un span sobre él con 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
// … índice 1 desde ldarg.1, índice 2 desde 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>)
Dos fuentes de span distintas, el mismo destino: una call a RingBuffer::Create sobre un ReadOnlySpan<int>. Ese destino es el invariante en el que Glass se ancla.
La heurística de recuperación
Glass trata la reconstrucción como una confirmación de cuatro puntos. Solo reescribirá una llamada como sintaxis de corchetes cuando se cumplan todos.
- La llamada es a un método estático que devuelve un tipo construido.
RingBuffer::Create<int32>devuelveRingBuffer<int>. Registra el tipo de retornoCy el métodoM. - La definición de
Clleva[CollectionBuilder]y nombra este método. Glass lee el blob del atributo personalizado sobreRingBuffer<T>: un argumentoSystem.Type(typeof(RingBuffer)) y unastring("Create"). El método llamado debe ser ese método en ese tipo. Una fábrica con la forma correcta pero sin el atributo apuntándola no es un generador. - El único argumento es un
ReadOnlySpan<E>cuyo tipo de elementoEcoincide con la instanciación del generador. - El span fue producido por una forma reconocida: ya sea
RuntimeHelpers.CreateSpan<E>sobre un campo de<PrivateImplementationDetails>, oInlineArrayAsReadOnlySpansobre un local<>y__InlineArrayNreciéninitobj-ado. Glass sigue el span hasta sus elementos: el blob RVA descodificado comoE, o los valores almacenados en cada ranura del arreglo en línea.
Solo entonces emite [e0, e1, …], tipado hacia C. El atributo del paso 2 lo es todo: es el único metadato que distingue «una fábrica que alguien llamó con un span» de «el generador que el lenguaje cableó a los corchetes».
El caso que no puede decidir
Aquí está el límite honesto, y es genuino en lugar de un error. Considera dos fuentes:
RingBuffer<int> a = [1, 2, 3];
RingBuffer<int> b = RingBuffer.Create([1, 2, 3]);
La primera es una expresión de colección que apunta a RingBuffer<int>. La segunda es una llamada explícita a Create, cuyo argumento [1, 2, 3] es una expresión de colección que apunta al parámetro ReadOnlySpan<int>. Ambas compilan a un IL idéntico byte a byte: el mismo CreateSpan y la misma call RingBuffer::Create. Ningún metadato las separa, porque a nivel de IL no hay nada que separar: el lenguaje define la primera como abreviatura de la segunda.
Glass resuelve el empate con una regla, no con una suposición: cuando el resultado de la llamada al generador es él mismo el valor directo de una posición tipada hacia el tipo de colección —un inicializador de local, un return, un argumento que espera RingBuffer<int>— prefiere la forma de corchetes e imprime [1, 2, 3]. Cuando el resultado fluye a algún lugar que no está tipado hacia la colección (se indexa de inmediato, se pasa donde se quiere un ReadOnlySpan mediante una conversión implícita, o el generador es un método que claramente querías ver), deja intacto RingBuffer.Create([1, 2, 3]). Ambas representaciones vuelven a compilar al ensamblado original; la elección es sobre cuál preferiría leer un humano, y el criterio de desempate está documentado para que la salida nunca sea silenciosamente engañosa.
Un segundo límite que vale la pena mencionar: si el método generador no es genérico, o vive en un tipo no relacionado con la colección, o el span proviene de una fuente que Glass no reconoce (por ejemplo, un ReadOnlySpan<T> devuelto por tu propio auxiliar), la comprobación de cuatro puntos falla de forma segura y obtienes la call literal. Esa es la respuesta correcta: cualquier otra cosa sería invención.
Usar esto al leer código
Cuando abres un ensamblado en Glass y ves un [...] desnudo sobre un tipo que no reconoces como una colección integrada, esa es tu señal: el tipo lleva [CollectionBuilder], y hay una fábrica estática a un salto de distancia que define cómo se construye. Salta al atributo (la vista de IL muestra el blob; la vista descompilada muestra el [CollectionBuilder(typeof(...), "...")] reconstruido sobre el tipo) y habrás encontrado el verdadero constructor que los corchetes ocultaban. A la inversa, cuando ves un Xyz.Create([...]) explícito, Glass te está diciendo que no pudo demostrar que la llamada externa fuera azúcar: léelo como una invocación de fábrica deliberada.
Conclusión
Una expresión de colección con [CollectionBuilder] no deja rastro sintáctico en el IL: solo un span y una llamada estática. Glass la reconstruye razonando a partir del atributo en el tipo de destino y de la forma del span, no a partir de ninguna instrucción, y donde dos fuentes legales colapsan a los mismos bytes, aplica un criterio de desempate declarado y reversible en lugar de fingir que sabe cuál escribiste. Leer los corchetes recuperados, y saber cuándo son una decisión en vez de un hecho, es la diferencia entre confiar en un descompilador y ser sorprendido por él.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.