Cómo lee Glass las instanciaciones de métodos genéricos
Una llamada a un método genérico se compila en un token MethodSpec con un blob de argumentos de tipo aparte. Así es como Glass.NET lee ese blob, sustituye los marcadores !!0 y decide cuándo el C# recuperado necesita realmente argumentos de tipo explícitos.
Llama dos veces a un método genérico con tipos diferentes y el compilador no copia el método. Emite el cuerpo una sola vez, contra marcadores, y registra los argumentos de tipo de cada llamada en una estructura minúscula aparte. Un descompilador que no entienda esa separación perderá los argumentos de tipo o los imprimirá donde C# nunca los habría escrito. Este es el mecanismo que usa Glass.NET para acertar exactamente.
La pregunta de fondo
Considera un método genérico sobre un tipo y las dos llamadas que lo instancian:
using System;
static class Program
{
static T Max<T>(T a, T b) where T : IComparable<T>
=> a.CompareTo(b) >= 0 ? a : b;
static void Main()
{
int m = Max(3, 7);
string s = Max("a", "b");
Console.WriteLine($"{m} {s}");
}
}
Hay un solo Max en el ensamblado compilado. Su cuerpo se escribe contra un parámetro de tipo, no contra int ni string. Entonces, ¿a dónde fueron a parar el int y el string, y cómo los vuelve a colocar Glass sin inventar corchetes que el código fuente nunca tuvo?
El cuerpo se escribe una sola vez, contra marcadores
Descompila la definición del método y el parámetro genérico aparece como !!T allí donde había una T en el código fuente:
.method private hidebysig static !!T
Max<([System.Runtime]System.IComparable`1<!!T>) T>(!!T a, !!T b) cil managed
{
ldarga.s a
ldarg.1
constrained. !!T
callvirt instance int32 class [System.Runtime]System.IComparable`1<!!T>::CompareTo(!0)
ldc.i4.0
blt.s IL_000f
ldarg.0
ret
IL_000f: ldarg.1
ret
}
Aquí entran en juego dos espacios de índices, y distinguirlos es toda la clave. !!T (dos signos) es el parámetro genérico del método. El !0 (un signo) dentro de IComparable 1<!!T>::CompareTo(!0)es el parámetro genérico del **tipo**: el único parámetro deIComparable<>` en sí. La CLI mantiene los parámetros de método y de tipo en espacios de numeración separados precisamente para que un método genérico sobre un tipo genérico nunca tenga que desambiguar el índice 0 frente al índice 0.
Fíjate también en el prefijo constrained. !!T: como T puede ser un tipo por valor, el compilador no sabe en tiempo de compilación si CompareTo necesita un callvirt con boxing. El prefijo delega esa decisión al JIT, que llama al método del struct directamente sin asignación. Es una consecuencia directa de where T : IComparable<T>, y Glass restituye la restricción a la firma del método en lugar de descartarla.
Los argumentos de tipo residen en un MethodSpec
El cuerpo nunca menciona int. Así que el punto de llamada debe llevar la instanciación. Descompila Main y cada llamada es una sola instrucción contra un token MethodSpec:
ldc.i4.3
ldc.i4.7
call !!0 Program::Max<int32>(!!0, !!0)
...
ldstr "a"
ldstr "b"
call !!0 Program::Max<string>(!!0, !!0)
Ambas instrucciones apuntan a la misma definición de método genérico, pero a través de dos filas MethodSpec distintas (tabla de metadatos 0x2B). Cada fila tiene dos columnas: Method, una referencia al Max genérico, e Instantiation, un índice de blob. El blob es una firma GENERICINST: un marcador de convención de llamada de un byte 0x0A, un recuento de argumentos y luego un tipo codificado por argumento.
Para Max<int32> los bytes del blob son 0A 01 08: convención de llamada GENERICINST (0x0A), un argumento (0x01) y ELEMENT_TYPE_I4 (0x08). Para Max<string> el byte final es 0x0E (ELEMENT_TYPE_STRING). Tres bytes son toda la diferencia entre las dos llamadas. Todo lo demás —el cuerpo, la lista de parámetros, el retorno— es compartido.
Sustituir y luego decidir sobre los corchetes
Glass recorre esto en dos movimientos. Primero resuelve el MethodSpec: sigue Method hasta el genérico abierto Max<T>, lee Instantiation para obtener los argumentos de tipo ordenados [Int32] y vincula !!0 a Int32. Solo con eso ya basta para imprimir un correcto, aunque verboso, Max<int>(3, 7).
El segundo movimiento es lo que hace que la salida se lea como código fuente. C# permite omitir los argumentos de tipo cuando el compilador puede inferirlos a partir de los argumentos normales. Aquí ambos parámetros son de tipo T y ambos argumentos son int, de modo que la inferencia recupera T = int por sí sola, que es por lo que el código fuente escribió Max(3, 7) y no Max<int>(3, 7). Glass lo reproduce: tras la sustitución pregunta si volver a ejecutar la inferencia sobre la llamada sin anotar llegaría al mismo método cerrado. Cuando así es, se eliminan los corchetes.
Cuando la inferencia no puede recuperar los argumentos, Glass los conserva. El caso clásico es un argumento de tipo que aparece solo en la posición de retorno:
static T Create<T>() where T : new() => new T();
var list = Create<List<int>>(); // no hay argumento del que inferir
Create no tiene parámetros, así que nada en el punto de llamada restringe a T. El IL lleva Create<class List1en su MethodSpec, y Glass debe emitirCreate<List
Cuando la heurística tiene que ser conservadora
La recuperación por inferencia es una decisión de criterio, y Glass se inclina por la corrección antes que por la brevedad. Si un método está sobrecargado de forma que quitar los argumentos de tipo haría ganar a una sobrecarga distinta —o haría ambigua la llamada—, Glass conserva los argumentos explícitos aunque el código original pudiera haberse apoyado en la inferencia. El código descompilado resulta entonces algo más verboso que el fuente, pero compila de forma demostrable al mismo MethodSpec. Ese compromiso es deliberado: un descompilador que produce código más corto que se vincula al método equivocado es peor que inútil.
El otro límite honesto: los nombres de los argumentos de tipo se han perdido. Un blob codifica System.Int32, nunca el hecho de que la T inferida del autor se escribiera TKey en alguna otra definición. Los nombres de los parámetros genéricos en las definiciones sobreviven en los metadatos; los tipos vinculados a ellos en un punto de llamada son estructurales, así que Glass imprime el tipo real, int, que es de todos modos lo que ve el runtime.
Conclusión
Una llamada genérica en .NET es una unión: un cuerpo compartido contra marcadores, más un MethodSpec por punto de llamada cuyo blob lleva los tipos reales. Lee el blob, vincula !!0 hasta !!n, mantén los parámetros de método y de tipo en sus espacios de índices separados y luego deja que la inferencia decida los corchetes, y la llamada descompilada se lee exactamente como el C# que la produjo. Glass.NET hace esto en cada punto de llamada genérico, por lo que la salida es legible en lugar de un muro de corchetes angulares. Consulta la vista de IL y metadatos para inspeccionar tú mismo las filas MethodSpec.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.