Indicizzatori delle estensioni

Questione prioritaria: https://github.com/dotnet/csharplang/issues/9856

Dichiarazione

Grammatica

Gli indicizzatori di estensione vengono aggiunti al set di membri consentiti all'interno di una dichiarazione di estensione estendendo la grammatica come indicato di seguito (rispetto alle proposte/csharp-14.0/extensions.md):

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

Come gli indicizzatori ordinari, gli indicizzatori di estensione non hanno identificatore e sono identificati dal relativo elenco di parametri. Gli indicizzatori di estensione possono usare il set completo di funzionalità attualmente supportate dagli indicizzatori ordinari (corpi delle funzioni di accesso, membri con corpo di espressione, funzioni di accesso che restituiscono riferimenti, scoped parametri, attributi e così via).

Poiché gli indicizzatori sono sempre membri dell'istanza, un blocco di estensione che dichiara un indicizzatore deve fornire un parametro ricevitore denominato.

Le restrizioni esistenti sui membri dell'estensione continuano a essere applicate: gli indicizzatori all'interno di una dichiarazione di estensione non possono specificare abstract, sealedvirtualnewpartialoverrideprotected o uno dei modificatori di accessibilità correlati o init le funzioni di accesso.

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

Tutte le regole dello standard C# applicabili agli indicizzatori ordinari si applicano agli indicizzatori di estensione, ma i membri dell'estensione non dispongono di un oggetto implicito o esplicito this.

La regola di inferrità del membro di estensione esistente si applica ancora: per ogni membro dell'estensione non metodo, tutti i parametri di tipo del relativo blocco di estensione devono essere usati nel set combinato di parametri dell'estensione e del membro.

Attributo IndexerName

IndexerNameAttribute può essere applicato a un indicizzatore di estensioni. L'attributo non viene generato nei metadati, ma il relativo valore influisce sui conflitti tra i membri, determina il nome della proprietà e delle funzioni di accesso nei metadati e viene usato durante l'emissione [DefaultMemberAttribute] (vedere Metadati).

Consumption

Accesso all'indicizzatore

Le regole nell'accesso all'indicizzatore vengono aggiornate: se la normale elaborazione dell'accesso dell'indicizzatore non trova alcun indicizzatore applicabile, viene effettuato un tentativo di elaborare il costrutto come accesso all'indicizzatore di estensione.

1. Tentare di eseguire l'associazione usando gli indicizzatori dell'istanza dichiarati (o ereditati) nel tipo di ricevitore. Se viene trovato un candidato applicabile, la risoluzione dell'overload seleziona tra i membri dell'istanza come oggi e si arresta.
2. Tentare di eseguire l'associazione usando gli indicizzatori di istanza impliciti dichiarati (o ereditati) nel tipo di ricevitore. Se viene trovato un candidato applicabile, la risoluzione dell'overload seleziona tra i membri dell'istanza come oggi e si arresta.
3. Tentare di eseguire l'associazione come accesso all'indicizzatore di estensione. Se questo processo trova un candidato applicabile, la risoluzione dell'overload seleziona tra i membri dell'estensione come descritto di seguito e si arresta.
4. Tentare di eseguire l'associazione come accesso implicito dell'indicizzatore di estensione. Se questo processo trova un candidato applicabile, la risoluzione dell'overload seleziona tra i membri dell'estensione come descritto di seguito e si arresta.

Nota: la sezione di accesso agli elementi gestisce il caso in cui un argomento ha tipo dynamic, quindi non viene mai elaborato come accesso all'indicizzatore.

Accesso all'indicizzatore di estensione

I membri di estensione, inclusi gli indicizzatori di estensione, non vengono mai considerati quando il ricevitore è un'espressione base_access .

Nota: un element_access viene elaborato solo come accesso dell'indicizzatore se il ricevitore è una variabile o un valore, quindi gli indicizzatori di estensione non vengono mai considerati quando il ricevitore è un tipo.

Dato un element_accessE[A], l'obiettivo è identificare un indicizzatore di estensioni.

Un indicizzatore di estensione candidato è applicabile per quanto riguarda l'elenco A di argomenti e ricevitore E se una firma espansa, costituita dai parametri di tipo del blocco di estensione e da un elenco di parametri che combina il parametro di estensione con i parametri dell'indicizzatore, è applicabile rispetto a un elenco di argomenti che combina il ricevitore E con l'elenco Adi argomenti .

Viene riutilizzata la procedura dettagliata dell'ambito del metodo di estensione: vengono attraversati gli stessi ambiti consultati per la chiamata al metodo di estensione, inclusi gli ambiti lessicali e gli ambiti lessicali o usingusing static le importazioni.

Considerando ogni ambito a sua volta:

• I blocchi di estensione nelle dichiarazioni di classe statiche non generiche nell'ambito corrente vengono considerati.
• Gli indicizzatori in tali blocchi di estensione comprendono il set candidato.
• I candidati non accessibili vengono rimossi dal set.
• I candidati non applicabili (come definito in precedenza) vengono rimossi dal set.
• Se il set risultante di indicizzatori candidati è vuoto, si procede con l'ambito successivo o non si risolve l'accesso di un indicizzatore di estensione se è stato raggiunto l'ultimo ambito (si continuerà a tentare di risolvere come indicizzatore implicito di estensione in questo caso).
• In caso contrario, la risoluzione dell'overload viene applicata al set candidato. Se non è possibile identificare un singolo indicizzatore migliore, l'accesso dell'indicizzatore di estensione è ambiguo e si verifica un errore in fase di compilazione.

Usando questo singolo indicizzatore migliore identificato nel passaggio precedente, l'accesso all'indicizzatore viene quindi elaborato come chiamata al metodo statico.

A seconda del contesto in cui viene usato, l'accesso di un indicizzatore provoca la chiamata del get_accessor o del set_accessor dell'indicizzatore.
Se l'accesso all'indicizzatore è la destinazione di un'assegnazione, viene richiamato il metodo di implementazione statico set_accessor per assegnare un nuovo valore.
In tutti gli altri casi, il metodo di implementazione statico get_accessor viene richiamato per ottenere il valore corrente.
In entrambi i casi, la chiamata userà argomenti generici dedotti durante il controllo dell'applicabilità e il ricevitore come primo argomento.

Accesso implicito dell'indicizzatore di estensione

Un accesso implicito System.Index all'estensione (o System.Range) dell'indicizzatore è applicabile se:

1. il element_access ha un singolo argomento di tipo System.Index (o System.Range) e
2. una proprietà applicabile Length o Count (istanza o estensione) si trova nel tipo di ricevitore e
3. Un indicizzatore applicabile this[int] (o Slice(int, int)) (istanza o estensione) viene trovato nel tipo di ricevitore.

Altri moduli di accesso a elementi

Qualsiasi costrutto che rinvia all'associazione di accesso agli elementi (accesso o assegnazioni di elementi condizionali Null, assegnazioni di indici negli inizializzatori di oggetti o modelli di elenco e diffusione) partecipa automaticamente alla risoluzione dell'indicizzatore di estensione descritta in precedenza.

Alberi delle espressioni

Gli indicizzatori di estensione non possono essere acquisiti negli alberi delle espressioni.

Documentazione XML

La sintassi CREF consente di fare riferimento a un indicizzatore di estensioni e alle relative funzioni di accesso, nonché ai relativi metodi di implementazione.

Esempio:

/// <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

Gli indicizzatori di estensione seguono lo stesso modello di riduzione delle proprietà di estensione. Per ogni tipo di raggruppamento di estensioni a livello di CLR che contiene almeno un indicizzatore, il compilatore genera:

• Proprietà di estensione denominata Item (o il valore fornito da IndexerNameAttribute) con corpi delle funzioni di accesso che throw NotImplementedException() e un [ExtensionMarkerName] attributo che fa riferimento al tipo di marcatore di estensione appropriato.
• Metodi di implementazione denominati get_Item/set_Item nella classe statica contenitore. Questi metodi anteponevano il parametro ricevitore all'elenco dei parametri e contengono i corpi definiti dall'utente. Sono static e partecipano alla risoluzione dell'overload nello stesso modo dei metodi di implementazione per le proprietà di estensione.

Per eseguire il mirroring del comportamento degli indicizzatori ordinari, il compilatore genera [DefaultMemberAttribute] anche su qualsiasi tipo di raggruppamento di estensioni che contiene uno o più indicizzatori di estensione. L'attributo MemberName è uguale al nome dei metadati dell'indicizzatore (Item per impostazione predefinita o al valore di IndexerNameAttribute).

Example

Codice sorgente:

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

Metadati generati (semplificati con sintassi simile 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) => ...;
}

Problemi aperti

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;
    }
}