Indexeurs d’extensions

Problème de champion : https://github.com/dotnet/csharplang/issues/9856

Déclaration

Grammaire

Les indexeurs d’extension sont ajoutés à l’ensemble de membres autorisés à l’intérieur d’une déclaration d’extension en étendant la grammaire comme suit (par rapport aux propositions/csharp-14.0/extensions.md) :

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

Comme les indexeurs ordinaires, les indexeurs d’extension n’ont pas d’identificateur et sont identifiés par leur liste de paramètres. Les indexeurs d’extension peuvent utiliser l’ensemble complet de fonctionnalités prises en charge par les indexeurs ordinaires aujourd’hui (corps d’accesseur, membres expression-bodied, accesseurs ref-retour, paramètres, scoped attributs, etc.).

Étant donné que les indexeurs sont toujours membres d’instance, un bloc d’extension qui déclare un indexeur doit fournir un paramètre de récepteur nommé.

Les restrictions existantes sur les membres d’extension continuent à s’appliquer : les indexeurs à l’intérieur d’une déclaration d’extension ne peuvent pas spécifier , virtual, , , , partial, ( protected ou l’un des modificateurs d’accessibilité associés) ou init les accesseurs. sealednewoverrideabstract

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

Toutes les règles de la norme C# qui s’appliquent aux indexeurs ordinaires s’appliquent aux indexeurs d’extension, mais les membres d’extension n’ont pas d’indexeurs implicites ou explicites this.

La règle d’inférence du membre d’extension existant s’applique toujours : pour chaque membre d’extension non-méthode, tous les paramètres de type de son bloc d’extension doivent être utilisés dans l’ensemble combiné de paramètres de l’extension et du membre.

attribut IndexerName

IndexerNameAttribute peut être appliqué à un indexeur d’extension. L’attribut n’est pas émis dans les métadonnées, mais sa valeur affecte les conflits entre les membres, il détermine le nom de la propriété et des accesseurs dans les métadonnées et est utilisé lors de l’émission [DefaultMemberAttribute] (voir Métadonnées).

Consommation

Accès à l’indexeur

Les règles de l’accès Indexer sont mises à jour : si le traitement normal de l’accès de l’indexeur ne trouve aucun indexeur applicable, une tentative est effectuée pour traiter la construction en tant qu’accès à l’indexeur d’extension.

1. Tentez de lier à l’aide des indexeurs d’instance déclarés (ou hérités) sur le type de récepteur. Si un candidat applicable est trouvé, la résolution de surcharge sélectionne parmi ces membres d’instance comme aujourd’hui et s’arrête.
2. Tentez de lier à l’aide des indexeurs d’instance implicites déclarés (ou hérités) sur le type de récepteur. Si un candidat applicable est trouvé, la résolution de surcharge sélectionne parmi ces membres d’instance comme aujourd’hui et s’arrête.
3. Tentez de lier en tant qu’accès de l’indexeur d’extension. Si ce processus trouve un candidat applicable, la résolution de surcharge sélectionne parmi ces membres d’extension, comme décrit ci-dessous et s’arrête.
4. Tentative de liaison en tant qu’accès implicite d’indexeur d’extension. Si ce processus trouve un candidat applicable, la résolution de surcharge sélectionne parmi ces membres d’extension, comme décrit ci-dessous et s’arrête.

Remarque : la section d’accès à l’élément gère le cas où un argument a un type dynamic, de sorte qu’il n’est jamais traité en tant qu’accès indexeur.

Accès de l’indexeur d’extension

Les membres d’extension, y compris les indexeurs d’extension, ne sont jamais pris en compte lorsque le récepteur est une expression base_access .

Remarque : nous traitons uniquement une element_access en tant qu’accès d’indexeur si le récepteur est une variable ou une valeur. Par conséquent, les indexeurs d’extension ne sont jamais pris en compte lorsque le récepteur est un type.

Étant donné une element_accessE[A], l’objectif est d’identifier un indexeur d’extension.

Un indexeur d’extension candidat s’applique au récepteur E et à la liste A d’arguments si une signature développée, composée des paramètres de type du bloc d’extension et d’une liste de paramètres combinant le paramètre d’extension avec les paramètres de l’indexeur, s’applique à une liste d’arguments combinant le récepteur E à la liste d’arguments A.

Nous réutilisons l’étendue de la méthode d’extension : nous parcourons les mêmes étendues consultées pour l’appel de méthode d’extension, y compris les étendues lexicales actuelles et englobantes et using l’espace de noms ou using static les importations.

Compte tenu de chaque étendue à son tour :

• Les blocs d’extension dans les déclarations de classe statique non générique dans l’étendue actuelle sont pris en compte.
• Les indexeurs de ces blocs d’extension comprennent l’ensemble de candidats.
• Les candidats qui ne sont pas accessibles sont supprimés de l’ensemble.
• Les candidats qui ne sont pas applicables (tels que définis ci-dessus) sont supprimés de l’ensemble.
• Si l’ensemble obtenu d’indexeurs candidats est vide, nous procédons à l’étendue suivante ou ne parvenons pas à résoudre un accès d’indexeur d’extension si nous avons atteint la dernière étendue (nous continuerons à tenter de résoudre en tant qu’indexeur implicite d’extension dans ce cas).
• Sinon, la résolution de surcharge est appliquée à l’ensemble de candidats. Si un seul indexeur ne peut pas être identifié, l’accès à l’indexeur d’extension est ambigu et une erreur au moment de la compilation se produit.

À l’aide de cet indexeur unique identifié à l’étape précédente, l’accès de l’indexeur est ensuite traité en tant qu’appel de méthode statique.

Selon le contexte dans lequel il est utilisé, un accès indexeur provoque l’appel de l’get_accessor ou de l’set_accessor de l’indexeur.
Si l’accès de l’indexeur est la cible d’une affectation, la méthode d’implémentation statique set_accessor est appelée pour affecter une nouvelle valeur.
Dans tous les autres cas, la méthode d’implémentation statique get_accessor est appelée pour obtenir la valeur actuelle.
Dans les deux cas, l’appel utilise des arguments génériques déduits pendant la vérification de l’applicabilité et le récepteur comme premier argument.

Accès implicite à l’indexeur d’extension

Un accès implicite System.Index (ou System.Range) d’indexeur d’extension est applicable si :

1. le element_access a un seul argument de type System.Index (ou System.Range) et
2. une propriété applicable Length ou Count (instance ou extension) se trouve sur le type de récepteur et
3. un indexeur applicable this[int] (ou Slice(int, int)) (instance ou extension) se trouve sur le type de récepteur.

Autres formulaires d’accès aux éléments

Toute construction qui se reporte à la liaison d’accès aux éléments (accès ou affectations d’éléments conditionnels Null, affectations d’index dans les initialiseurs d’objet, liste et modèles de propagation) participe automatiquement à la résolution de l’indexeur d’extension décrite ci-dessus.

Arbres d'expression

Les indexeurs d’extension ne peuvent pas être capturés dans les arborescences d’expressions.

Documents XML

La syntaxe CREF permet de faire référence à un indexeur d’extension et à ses accesseurs, ainsi qu’à ses méthodes d’implémentation.

Exemple :

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

Les indexeurs d’extension suivent le même modèle de réduction que les propriétés d’extension. Pour chaque type de regroupement d’extensions de niveau CLR qui contient au moins un indexeur, le compilateur émet :

• Propriété d’extension nommée Item (ou valeur fournie par IndexerNameAttribute) avec des corps d’accesseur qui throw NotImplementedException() et un [ExtensionMarkerName] attribut référençant le type de marqueur d’extension approprié.
• Méthodes d’implémentation nommées get_Item/set_Item dans la classe statique englobante. Ces méthodes ont précédé le paramètre de récepteur dans la liste des paramètres et contiennent les corps définis par l’utilisateur. Ils sont static et participent à la résolution de surcharge de la même façon que les méthodes d’implémentation pour les propriétés d’extension.

Pour mettre en miroir le comportement des indexeurs ordinaires [DefaultMemberAttribute] , le compilateur émet également sur n’importe quel type de regroupement d’extensions qui contient un ou plusieurs indexeurs d’extension. L’attribut est égal au nom des métadonnées de l’indexeur MemberName (Item par défaut, ou à partir de la valeur de IndexerNameAttribute).

Example

Code source :

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

Métadonnées émises (simplifiées en syntaxe C#-like) :

[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) => ...;
}

Problèmes ouverts

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