Partage via

Autoriser les nouvelles lignes dans toutes les interpolations

  • Article

Remarque

Cet article est une spécification de fonctionnalité. La spécification sert de document de conception pour la fonctionnalité. Elle inclut les changements de spécification proposés, ainsi que les informations nécessaires à la conception et au développement de la fonctionnalité. Ces articles sont publiés jusqu'à ce que les changements proposés soient finalisés et incorporés dans la spécification ECMA actuelle.

Il peut y avoir des différences entre la spécification de la fonctionnalité et l'implémentation réalisée. Ces différences sont consignées dans les notes pertinentes de la réunion de conception linguistique (LDM).

Pour en savoir plus sur le processus d'adoption des speclets de fonctionnalité dans la norme du langage C#, consultez l'article sur les spécifications.

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

Récapitulatif

Le langage actuel traite différemment les chaînes interpolées non verbatim et verbatim ($"" et $@"" respectivement). La principale différence significative est qu'une chaîne interpolée non verbatim fonctionne comme une chaîne normale et ne peut pas contenir de nouvelles lignes dans ses segments de texte, et doit à la place utiliser des échappements (comme \r\n). Inversement, une chaîne interpolée verbatim peut contenir des nouvelles lignes dans ses segments de texte (comme une chaîne verbatim), et n'échappe pas aux nouvelles lignes ou à d'autres caractères (à l'exception de "" pour échapper à un guillemet lui-même).

Tout cela est raisonnable et ne changera pas avec cette proposition.

Ce qui est déraisonnable aujourd'hui, c'est que nous étendions la restriction « pas de nouvelles lignes » dans une chaîne interpolée non verbatim au-delà de ses segments de texte, dans les interpolations elles-mêmes. Cela signifie, par exemple, que vous ne pouvez pas écrire les éléments suivants :

var v = $"Count is\t: { this.Is.A.Really(long(expr))
                            .That.I.Should(
                                be + able)[
                                    to.Wrap()] }.";

En fin de compte, la règle selon laquelle « l’interpolation doit être sur une seule ligne » est simplement une restriction de l’implémentation actuelle. Cette restriction n’est vraiment pas nécessaire, peut être ennuyeuse et serait assez triviale à supprimer ; voir le travail https://github.com/dotnet/roslyn/pull/54875 pour savoir comment procéder. En fin de compte, tout ce que cela fait, c'est forcer le développeur à placer les choses sur une seule ligne, ou à les forcer dans une chaîne interpolée verbatim (les deux pouvant être désagréables).

Les expressions d'interpolation elles-mêmes ne sont pas du texte et ne devraient pas être soumises à des règles d'échappement ou de remplacement de lignes.

Modification des spécifications

single_regular_balanced_text_character
-    : '<Any character except / (U+002F), @ (U+0040), \" (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D) and new_line_character>'
-    | '</ (U+002F), if not directly followed by / (U+002F) or * (U+002A)>'
+    : <Any character except @ (U+0040), \" (U+0022), $ (U+0024), ( (U+0028), ) (U+0029), [ (U+005B), ] (U+005D), { (U+007B), } (U+007D)>
+    | comment
    ;

Discussions sur le LDM

https://github.com/dotnet/csharplang/blob/main/meetings/2021/LDM-2021-09-20.md