Indexadores de extensión

Problema planteado por el experto: https://github.com/dotnet/csharplang/issues/9856

Declaración

Gramática

Los indexadores de extensión se agregan al conjunto de miembros permitidos dentro de una declaración de extensión mediante la extensión como se indica a continuación (en relación con las propuestas/csharp-14.0/extensions.md):

extension_member_declaration
        : method_declaration
        | property_declaration
        | indexer_declaration // new
        | operator_declaration
        ;

Al igual que los indexadores normales, los indexadores de extensión no tienen ningún identificador y se identifican mediante su lista de parámetros. Los indexadores de extensión pueden usar el conjunto completo de características que los indexadores normales admiten hoy (cuerpos de descriptor de acceso, miembros con forma de expresión, descriptores de acceso que devuelven referencias, scoped parámetros, atributos, etc.).

Dado que los indexadores siempre son miembros de instancia, un bloque de extensión que declara un indexador debe proporcionar un parámetro receptor con nombre.

Las restricciones existentes en los miembros de extensión siguen aplicándose: los indexadores dentro de una declaración de extensión no pueden especificar abstract, , newoverridevirtual, sealed, , partialprotected o cualquiera de los modificadores de accesibilidad relacionados o init descriptores de acceso.

public static class BitExtensions
{
    extension(int i)
    {
        public bool this[int index]
        {
            get => ...;
        }
    }
}

Todas las reglas del estándar de C# que se aplican a los indexadores normales se aplican a los indexadores de extensión, pero los miembros de extensión no tienen un elemento implícito o explícito this.

La regla de inferencia de miembro de extensión existente todavía se aplica: para cada miembro de extensión que no sea de método, todos los parámetros de tipo de su bloque de extensión se deben usar en el conjunto combinado de parámetros de la extensión y el miembro.

atributo IndexerName

IndexerNameAttribute se puede aplicar a un indexador de extensión. El atributo no se emite en los metadatos, pero su valor afecta a conflictos entre miembros, determina el nombre de la propiedad y los descriptores de acceso en los metadatos y se usa al emitir [DefaultMemberAttribute] (vea Metadatos).

Consumo

Acceso a indizador

Las reglas del acceso al indexador se actualizan: si el procesamiento normal del acceso al indexador no encuentra ningún indexador aplicable, se intenta procesar la construcción como acceso al indexador de extensión.

1. Intente enlazar mediante los indexadores de instancia declarados (o heredados) en el tipo de receptor. Si se encuentra un candidato aplicable, la resolución de sobrecarga selecciona entre esos miembros de instancia como hoy y se detiene.
2. Intente enlazar mediante los indexadores de instancia implícitos declarados (o heredados) en el tipo de receptor. Si se encuentra un candidato aplicable, la resolución de sobrecarga selecciona entre esos miembros de instancia como hoy y se detiene.
3. Intente enlazar como acceso de indexador de extensión. Si este proceso encuentra un candidato aplicable, la resolución de sobrecarga selecciona entre esos miembros de extensión, tal como se describe a continuación y se detiene.
4. Intente enlazar como acceso implícito al indexador de extensión. Si este proceso encuentra un candidato aplicable, la resolución de sobrecarga selecciona entre esos miembros de extensión, tal como se describe a continuación y se detiene.

Nota: la sección de acceso al elemento controla el caso en el que un argumento tiene el tipo dynamic, por lo que nunca se procesa como acceso de indizador.

Acceso al indexador de extensiones

Los miembros de extensión, incluidos los indexadores de extensión, nunca se consideran cuando el receptor es una expresión base_access .

Nota: Solo procesamos un element_access como acceso de indexador si el receptor es una variable o un valor, por lo que los indexadores de extensión nunca se consideran cuando el receptor es un tipo.

Dado un element_accessE[A], el objetivo es identificar un indexador de extensión.

Un indexador de extensión candidata se aplica con respecto a la lista A de argumentos y receptor E si una firma expandida, formada por los parámetros de tipo del bloque de extensión y una lista de parámetros que combina el parámetro de extensión con los parámetros del indexador, es aplicable con respecto a una lista de argumentos que combina el receptor E con la lista Ade argumentos .

Reutilizamos el ámbito del método de extensión: recorremos los mismos ámbitos consultados para la invocación del método de extensión, incluidos los ámbitos léxicos actuales y envolventes y using el espacio de nombres o using static las importaciones.

Teniendo en cuenta cada ámbito a su vez:

• Los bloques de extensión en declaraciones de clase estática no genéricas en el ámbito actual se consideran.
• Los indexadores de esos bloques de extensión componen el conjunto candidato.
• Los candidatos que no son accesibles se quitan del conjunto.
• Los candidatos que no son aplicables (como se definió anteriormente) se quitan del conjunto.
• Si el conjunto resultante de indexadores candidatos está vacío, vamos al siguiente ámbito o no se puede resolver un acceso de indexador de extensión si llegamos al último ámbito (continuaremos intentando resolverlo como un indexador implícito de extensión en ese caso).
• De lo contrario, la resolución de sobrecarga se aplica al conjunto candidato. Si no se puede identificar un único indexador mejor, el acceso al indexador de extensión es ambiguo y se produce un error en tiempo de compilación.

Con este único mejor indexador identificado en el paso anterior, el acceso al indexador se procesa después como una invocación de método estático.

Dependiendo del contexto en el que se use, un acceso de indexador provoca la invocación de la get_accessor o el set_accessor del indexador.
Si el acceso del indexador es el destino de una asignación, se invoca al set_accessor método de implementación estático para asignar un nuevo valor.
En todos los demás casos, se invoca el get_accessor método de implementación estática para obtener el valor actual.
En cualquier caso, la invocación usará argumentos genéricos inferidos durante la comprobación de aplicabilidad y el receptor como primer argumento.

Acceso al indexador implícito de extensión

Si se aplica un acceso implícito System.Index de extensión (o System.Range) al indizador:

1. el element_access tiene un único argumento de tipo System.Index (o System.Range) y
2. Se encuentra una propiedad aplicable Length o Count (instancia o extensión) en el tipo de receptor y
3. Se encuentra un indexador aplicable this[int] (o Slice(int, int)) (instancia o extensión) en el tipo de receptor.

Otros formularios de acceso a elementos

Cualquier construcción que se aplaza al enlace de acceso a elementos (acceso o asignaciones de elementos condicionales NULL, asignaciones de índice en inicializadores de objetos o patrones de lista y propagación) participa automáticamente en la resolución del indexador de extensión descrita anteriormente.

Árboles de expresión

Los indexadores de extensión no se pueden capturar en árboles de expresión.

Documentos XML

La sintaxis CREF permite hacer referencia a un indexador de extensión y sus descriptores de acceso, así como a sus métodos de implementación.

Ejemplo:

/// <see cref="E.extension(int).this[string]"/>
/// <see cref="E.extension(int).get_Item(string)"/>
/// <see cref="E.extension(int).get_Item"/>
/// <see cref="E.extension(int).set_Item(string, int)"/>
/// <see cref="E.extension(int).set_Item"/>
/// <see cref="E.get_Item(int, string)"/>
/// <see cref="E.get_Item"/>
/// <see cref="E.set_Item(int, string, int)"/>
/// <see cref="E.set_Item"/>
public static class E
{
    extension(int i)
    {
        /// <summary></summary>
        public int this[string s]
        {
            get => throw null;
            set => throw null;
        }
    }
}

Metadata

Los indexadores de extensión siguen el mismo modelo de reducción que las propiedades de la extensión. Para cada tipo de agrupación de extensiones de nivel CLR que contenga al menos un indexador, el compilador emite:

• Una propiedad de extensión denominada Item (o el valor proporcionado por IndexerNameAttribute) con cuerpos de descriptor de acceso que y un [ExtensionMarkerName] atributo que throw NotImplementedException() hace referencia al tipo de marcador de extensión adecuado.
• Métodos de implementación denominados get_Item/set_Item en la clase estática envolvente. Estos métodos anteponen el parámetro receiver a la lista de parámetros y contienen los cuerpos definidos por el usuario. Son static y participan en la resolución de sobrecargas de la misma manera que los métodos de implementación para las propiedades de extensión.

Para reflejar el comportamiento de los indexadores normales, el compilador también emite [DefaultMemberAttribute] en cualquier tipo de agrupación de extensiones que contenga uno o varios indexadores de extensión. El atributo MemberName es igual al nombre de metadatos del indexador (Item de forma predeterminada, o el valor de IndexerNameAttribute).

Example

Código fuente:

static class BitExtensions
{
    extension<T>(T t)
    {
        public bool this[int index]
        {
            get => ...;
            set => ...;
        }
    }
}

Metadatos emitidos (simplificado a la sintaxis similar a C#):

[Extension]
static class BitExtensions
{
    [Extension, SpecialName, DefaultMember("Item")]
    public sealed class <G>$T0 // grouping type
    {
        [SpecialName]
        public static class <M>$T_t // marker type
        {
            [SpecialName]
            public static void <Extension>$(T t) { } // marker method
        }

        [ExtensionMarkerName("<M>$T_t")]
        public bool this[int index] // extension indexer
        {
            get => throw new NotImplementedException();
            set => throw new NotImplementedException();
        }
    }

    // accessor implementation methods
    public static bool get_Item<T>(T t, int index) => ...;
    public static void set_Item<T>(T t, int index, bool value) => ...;
}

Problemas abiertos

int i = 0;
i[42, null] = new object(); // fails inference
E.set_Item(i, 42, null, new object()); // infer `E.set_Item<object>`

public static class E
{
    extension<T>(int i)
    {
        public T this[int j, T t] { set { } }
    }
}

#nullable enable

int i = 0;
i[new object()] = null; // infer `E.extension<object!>` and warn on conversion of null literal to `object!`
E.set_Item(i, new object(), null); // infer `E.set_Item<object?>`

public static class E
{
    extension<T>(int i)
    {
        public T this[T t] { set { } }
    }
}

C c = new C();
_ = c[..]; // Cannot apply indexing with [] to an expression of type 'C'

class C
{
    public int Length => 0;
}

static class E
{
    public static C Slice(this C c, int i, int j) => null!;
}

C c = new C();
var x1 = c[^1];
var x2 = c[1..];

if (c is [.., var y1]) { }
if (c is [_, .. var y2]) { }

class C { }

static class E
{
  extension(C c)
  {
    object this[System.Index] => ...;
    C this[System.Range] => ...;
    int Length => ...;
  }
}

C c = new C();
if (c is [var y1, .. var y2]) { }

class C
{
  C Slice(int i, int j) => ...;
}

static class E
{
  extension(C c)
  {
    object this[System.Index] => ...;
    int Length => ...;
  }
}

C c = new C();
_ = c[^1];

class C
{
  public int Length => ...;
  public int this[int i] => ...;
}

static class E
{
  extension(C c)
  {
    public int this[System.Index i] => ...;
  }
}

_ = c[1..^1];

static class E
{
  extension(C c)
  {
    public int Length => 3;
  }
  public static C Slice(this C c, int i, int j) => ...;
}

C c = new C();
int[] i = [0, .. c]; // Uses Length, if available, to allocate the right size

int[] i = ...;
_ = i[new C()];

public static class E
{
    extension(int[] i)
    {
        public int this[C c] => throw null;
    }
}

string s = "...;
_ = s[new C()];

public static class E
{
    extension(int[] i)
    {
        public int this[C c] => throw null;
    }
}