Descompilar [OverloadResolutionPriority]: una decisión en tiempo de compilación congelada en la llamada
El atributo OverloadResolutionPriority dirige la resolución de sobrecargas, pero marca solo la definición del método, nunca la llamada. Así lo lee Glass.NET en ambos lados.
C# 13 añadió una herramienta pequeña y afilada a las reglas de resolución de sobrecargas: [OverloadResolutionPriority]. Lo pones sobre un miembro de un grupo de sobrecargas y le das un entero; entre los candidatos que el compilador ya considera aplicables, gana el de mayor prioridad, anulando los desempates habituales de “cuál es mejor”. El BCL de .NET 9 lo usa para que las sobrecargas basadas en span tengan precedencia silenciosa sobre sus hermanas más antiguas basadas en arrays y cadenas, de modo que los puntos de llamada existentes enlacen con la ruta más rápida al recompilar, sin cambiar el código fuente y sin un error de ambigüedad.
También es un problema de descompilación genuinamente interesante, y por la razón opuesta a la de la mayoría de los constructos sobre los que hemos escrito. La palabra clave field es invisible en los metadatos y visible solo en el IL del descriptor de acceso. [OverloadResolutionPriority] es lo contrario: es perfectamente visible en la definición y completamente invisible en el punto de llamada. El atributo es una directiva en tiempo de compilación cuyo único trabajo es dirigir una decisión, y una vez tomada esa decisión no deja huella alguna en el código que se benefició de ella. Este artículo muestra los metadatos que escribe, el IL del punto de llamada que no escribe y cómo Glass.NET lee cada lado por lo que realmente es.
El grupo de sobrecargas y el atributo
Esta es la forma que el BCL adoptó docenas de veces en .NET 9: una sobrecarga más antigua que toma un array y otra más nueva y rápida que toma un ReadOnlySpan<T>. Ambas son aplicables cuando pasas un array, porque existe una conversión implícita de array a span. Históricamente ganaba la sobrecarga de array (es una coincidencia exacta), así que una recompilación nunca pasaría a la ruta de span. El atributo da la vuelta a esto:
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 vive en System.Runtime.CompilerServices y se declara, en esencia, así:
[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 prioridad es un int corriente; el valor por defecto (todo lo no marcado) es 0, y los negativos reducen la prioridad de un miembro. La regla solo se aplica entre candidatos declarados en el mismo tipo, y solo después de que el compilador haya reducido el conjunto a los aplicables: es un desempate final, no una forma de llamar a algo que de otro modo no enlazaría.
Qué escribe el atributo en los metadatos
Aplicado a Add(ReadOnlySpan<int>), el atributo se compila en un único registro de atributo personalizado colgado de ese método:
.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 )
// ...
}
El blob se decodifica exactamente como el de cualquier atributo con un único argumento int32. El 01 00 inicial es el prólogo fijo. Los cuatro bytes siguientes 01 00 00 00 son el argumento int32 en little-endian: el valor 1. Los 00 00 finales indican que hay cero argumentos con nombre. No hay nada específico del constructo aquí: es la misma fila de la tabla CustomAttribute (0x0C) que producirían [Obsolete] o [MethodImpl], y se diferencia solo en su columna Type (el .ctor del atributo) y en su blob Value.
Esa es toda la huella en metadatos. Glass lee la fila, resuelve el token Type a OverloadResolutionPriorityAttribute, decodifica el blob contra la firma del constructor e imprime el atributo de vuelta tal cual sobre el método. Como el atributo es corriente, el ida y vuelta es limpio: lo que descompilas es lo que el autor escribió, valor de prioridad incluido. Puedes comprobar los bytes crudos tú mismo en el panel de metadatos de Glass, que muestra la fila CustomAttribute con su token padre y el blob literal, junto al C# renderizado.
El punto de llamada, donde el atributo no deja rastro
Ahora la mitad interesante. Este es código que llama al grupo con un argumento de array:
Sink.Add(new[] { 1, 2, 3 });
Por la prioridad, el compilador enlaza esto con la sobrecarga de span e inserta la conversión implícita de array a span. El IL emitido:
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>)
Compáralo con el IL que habrías obtenido antes de que existiera el atributo, cuando ganaba la sobrecarga de array:
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[])
Los dos se diferencian solo en qué Sink::Add se nombra, más la llamada op_Implicit que necesita la ruta de span. Ninguno de los dos flujos de IL contiene referencia alguna a OverloadResolutionPriority. El atributo hizo su trabajo enteramente en tiempo de compilación: inclinó la resolución, la resolución produjo una llamada enlazada y la llamada enlazada es todo lo que el IL recuerda. Al leer el llamador, un descompilador no puede decir “aquí se consultó una prioridad de resolución de sobrecargas”: no hay nada que leer. Solo puede informar del método que de hecho se invocó.
Por qué “fiel al IL” es el comportamiento correcto
Sería tentador imaginar un descompilador que, al ver una llamada a la sobrecarga de span, “amablemente” simplificara el op_Implicit y mostrara Sink.Add(new[] { 1, 2, 3 }) como si no pasara nada especial. Glass hace exactamente eso a nivel de código fuente —renderiza la llamada natural de C#, porque es lo que el autor escribió— pero lo hace descompilando la llamada enlazada que encontró, no reejecutando la resolución de sobrecargas. Esa distinción importa.
Si Glass reresolviera la sobrecarga desde cero al renderizar el llamador, necesitaría conocer la prioridad para reproducir el enlace original. Los atributos se conservan en los ensamblados de referencia, así que la información suele estar ahí, pero un descompilador que depende de la reresolución está a una entrada mala de distancia (un atributo eliminado, un conjunto de referencias que no coincide) de reenlazar silenciosamente la llamada a la sobrecarga de array y producir código fuente que compila a un IL distinto. Al descompilar el flujo de instrucciones que el compilador de hecho emitió, Glass esquiva toda la cuestión: el destino elegido y su conversión son hechos en el IL, y Glass informa de hechos. El atributo de prioridad se renderiza donde vive —en la definición— y el punto de llamada se muestra como la llamada concreta que es.
Leerlo en la práctica
Apunta Glass al ensamblado y caen dos cosas con claridad. En el tipo Sink, la sobrecarga de span lleva [OverloadResolutionPriority(1)] exactamente como se escribió, y el panel de metadatos muestra la fila CustomAttribute de respaldo si quieres ver el blob. En cualquier llamador ves la llamada corriente y enlazada —a la sobrecarga de span, con la conversión de array a span en línea— y ninguna mención de la prioridad, porque no se emitió ninguna. Desde la CLI, la misma división aparece en el código fuente exportado:
glass decompile Sink.dll --type Sink --member Add
glass decompile App.dll --type Program --member Main
El primero imprime el atributo en la definición; el segundo imprime la llamada resuelta sin ningún atributo cerca. Esa asimetría no es un fallo de la herramienta: es una imagen honesta de lo que es [OverloadResolutionPriority], una instrucción en tiempo de compilación que documenta una intención en la definición y deja al resto del programa sin enterarse. Leerlo de vuelta tiene menos que ver con reconstruir y más con saber qué mitad del binario mirar, y confiar en el IL para la otra.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.