Google a annoncé la disponibilité de Go 1.21.  La nouveauté la plus remarquable est la fonctionnalité d'optimisation guidée par profil (PGO) qui venait en préversion avec Go 1.20 et qui est maintenant en disponibilité générale.

PGO permet au compilateur d'effectuer des optimisations spécifiques à l'application et à la charge de travail en fonction des informations de profil d'exécution. Notamment, via PGO, le compilateur effectue un inlining de fonction plus agressif. Google souligne que le compilateur Go lui-même a été reconstruit avec PGO activé pour 1.21, et par conséquent, il construit des programmes Go 2 à 4 % plus rapidement, selon l'architecture de l'hôte.

En ce qui concerne le langage lui-même, Go 1.21 apporte notamment plusieurs améliorations à l'inférence de types :

• Une fonction (éventuellement partiellement instanciée générique) peut désormais être appelée avec des arguments qui sont eux-mêmes (éventuellement partiellement instanciés) des fonctions génériques. Le compilateur tentera de déduire les arguments de type manquants de l'appelé (comme précédemment) et, pour chaque argument qui est une fonction générique qui n'est pas entièrement instanciée, ses arguments de type manquants (nouveau). Les cas d'utilisation typiques sont les appels à des fonctions génériques opérant sur des conteneurs (tels que slices.IndexFunc) où un argument de fonction peut également être générique et où l'argument de type de la fonction appelée et ses arguments sont déduits du type de conteneur. Plus généralement, une fonction générique peut désormais être utilisée sans instanciation explicite lorsqu'elle est affectée à une variable ou renvoyée comme valeur de résultat si les arguments de type peuvent être déduits de l'affectation.
• L'inférence de type prend désormais également en compte les méthodes lorsqu'une valeur est affectée à une interface : les arguments de type pour les paramètres de type utilisés dans les signatures de méthode peuvent être déduits des types de paramètres correspondants des méthodes correspondantes.
• De même, puisqu'un argument de type doit implémenter toutes les méthodes de sa contrainte correspondante, les méthodes de l'argument de type et de la contrainte sont appariées, ce qui peut conduire à l'inférence d'arguments de type supplémentaires.
• Si plusieurs arguments constants non typés de différents types (tels qu'un int non typé et une constante à virgule flottante non typée) sont passés à des paramètres avec le même type de paramètre de type (non spécifié autrement), au lieu d'une erreur, maintenant l'inférence de type détermine le type en utilisant la même approche qu'un opérateur avec des opérandes constants non typés. Cette modification aligne les types déduits des arguments constants non typés sur les types des expressions constantes.
• L'inférence de type est désormais précise lors de la mise en correspondance des types correspondants dans les affectations : les types de composants (tels que les éléments des tranches ou les types de paramètres dans les signatures de fonction) doivent être identiques (avec des arguments de type appropriés) pour correspondre, sinon l'inférence échoue. Cette modification produit des messages d'erreur plus précis : là où, dans le passé, l'inférence de type pouvait avoir réussi de manière incorrecte et conduire à une affectation non valide, le compilateur signale désormais une erreur d'inférence si deux types ne peuvent pas correspondre.

A remarquer encore, Go 1.21 inclut un aperçu d'un changement de langage qui est envisagé pour une future version de Go : créer des variables de boucle for par itération au lieu de par boucle, pour éviter les bogues de partage accidentels. Pour plus de détails ici : LoopvarExperiment.