IntelliJ Luanalysis
v1.4.0
Un IDE pour le développement LUA typique statiquement.
Dérivé de l'emmylua.
self est un vrai type@shape@not -type lance@type Annotations sur les déclarations de retour 
La dernière version est disponible en téléchargement dans Intellij ou sur le site Web du plugin JetBrains.
La luanalyse est dérivée de l'emmylua et prend en charge toutes les fonctionnalités d'édition et de refactorisation de base fournies par Emmylua.
Au-delà des capacités d'édition LUA de base, Luanalysis prend en charge une quantité importante de fonctionnalités supplémentaires nécessaires pour type statiquement basé sur des bases de code avancées.
* Remarque *: Les fonctionnalités sont approximativement répertoriées dans l'ordre où ils ont été mis en œuvre, en aucun cas l'ordre d'importance.
Un excellent moyen de voir ce qui est possible en termes de frappe statique est de vérifier le projet de démonstration de Luanalysis.
En plus de définir de nouveaux types, la balise @type peut désormais également être utilisée pour lancer le résultat d'une expression LUA.
Ceci est très utile avec la prise en charge nouvellement ajoutée pour les commentaires du bloc Emmydoc car nous pouvons facilement spécifier des moulages de type en ligne:
https://github.com/benjamin-dobell/luanalystypesdemo/blob/cfea19c9fd744078f50f61e74e620b7505b58c65/src/type_cast.lua
Emmylua tente de déterminer si un type est attribuable à un autre type en vérifiant si le premier est un "sous-type" de ces derniers, mais la variance de type appropriée des types complexes n'est pas implémentée. Par exemple, les fonctions peuvent être covariantes ou contravenantes d'autres types de fonctions, en fonction des paramètres et des types de valeur de retour:
Emmylua ne signale pas l'erreur ci-dessus.
De plus, la détection de la variance de l'Union a été fixée:
Comme ci-dessus, la libération actuelle d'Emmylua n'attrape pas cette erreur.
https://github.com/benjamin-dobell/luanalystypesdemo/blob/cfea19c9fd744078f50f61e74e620b7505b58c65/src/string_literals.lua
https://github.com/benjamin-dobell/luanalystypesdemo/blob/cfea19c9fd744078f50f61e74e620b7505b58c65/src/fonction_generics_scope.lua
IE Type La vérification fonctionne désormais à l'intérieur de la fonction "Lambdas" attribuée à une variable avec une définition d'emmydoc.
https://github.com/benjamin-dobell/luanalystypesdemo/blob/cfea19c9fd744078f50f61e74e620b7505b58c65/src/lambda_params.lua
Diverses améliorations, par exemple, les "tableaux" des Emmydoc sont désormais attribuables aux types de table compatibles, par exemple
La version actuelle d'Emmylua rapportera une erreur ici même si cela est solide.
https://github.com/benjamin-dobell/luanalystypesdemo/blob/cfea19c9fd744078f50f61e74e620b7505b58c65/src/tables.lua
https://github.com/benjamin-dobell/luanalystypesdemo/blob/cfea19c9fd744078f50f61e74e620b7505b58c65/src/generic_class_fields.lua
https://github.com/benjamin-dobell/luanalystypesdemo/blob/cfea19c9fd744078f50f61e74e620b7505b58c65/src/fonction_generrics.lua#l226-l249
La version actuelle d'Emmylua n'est pas en mesure de déduire correctement les génériques dans plusieurs situations et rapporte ainsi les erreurs de type en cas d'erreur, et manque également des erreurs où les erreurs doivent exister, par exemple
https://github.com/benjamin-dobell/luanalystypesdemo/blob/cfea19c9fd744078f50f61e74e620b7505b58c65/src/fonction_generrics.lua#l154-l181
Par défaut, les erreurs de sécurité de type sont désormais signalées comme des erreurs au lieu des avertissements. Ceci est rendu possible par trois choses:
De nombreuses améliorations de la capacité de spécifier des types complexes
Tapez des corrections de bugs de sécurité
Fonderie
Le casting en particulier signifie que si un utilisateur fait quelque chose que le système de type juge dangereux, mais qu'il sait au moment de l'exécution ira bien, il peut simplement ajouter un casting pour signifier cela et l'erreur disparaîtra.
L'observation d'un paramètre générique est interdite et un rapport d'erreur:
https://github.com/benjamin-dobell/luanalystypesdemo/blob/cfea19c9fd744078f50f61e74e620b7505b58c65/src/generic_class_scope.lua
https://github.com/benjamin-dobell/luanalystypesdemo/blob/cfea19c9fd744078f50f61e74e620b7505b58c65/src/generic_class_fields.lua#l44-l45
self est un vrai type La vérification de type améliorée pour self , par exemple self peut être attribuée à une variable qui correspond au type parent d'une méthode. Cependant, ce type de parent ne peut pas être affecté à self , car la classe peut être sous-claire (auquel cas self fait référence à un type plus spécifique).
https://github.com/benjamin-dobell/luanalystypesdemo/blob/cfea19c9fd744078f50f61e74e620b7505b58c65/src/self.lua
La version actuelle d'Emmylua permettra cette affectation non valide.
Lorsqu'une fonction renvoie plusieurs valeurs, la libération actuelle d'Emmylua inférera les valeurs et les mettra dans le cache. Ceci est inexact car l'analyse des types génériques peut entraîner la résolution du même paramètre générique en fonction de la valeur attribuée, donc le cache ne peut pas être utilisé dans cette circonstance. Actuellement, il en résulte à la fois des erreurs manquantes et des erreurs inexactes supplémentaires, selon l'affectation.
@shapeUne forme peut être définie de manière similaire à une classe, sauf que la contavariation est déterminée par la compatibilité des membres et non la hiérarchie de l'héritage.
Ceci est très utile lorsque vous travaillez avec des "structures" (par exemple JSON) plutôt que des classes OOP.
https://github.com/benjamin-dobell/luanalystypesdemo/blob/cfea19c9fd744078f50f61e74e620b7505b58c65/src/shape.lua
Ce qui rend les formes particulièrement utiles, c'est qu'elles prennent en charge les génériques et l'héritage (au moment de la définition, pas à l'attribution) tout comme les classes:
https://github.com/benjamin-dobell/luanalystypesdemo/blob/cfea19c9fd744078f50f61e74e620b7505b58c65/src/shape.lua#l36-l74
Encore mieux , les inspections de type ne sont pas seulement rapportées sur l'incompatible «Table
Les alias peuvent désormais prendre des paramètres génériques, tout comme une classe ou une forme.
https://github.com/benjamin-dobell/luanalysistypesdemo/blob/cfea19c9fd744078f50f61e74e620b7505b58c65/src/generic_alia.lua
Les types de fonction peuvent désormais utiliser …: T comme alternative à vararg T :
Nous prenons maintenant en charge les valeurs de retour variadiques:
En interne, TyTuple a été remplacé par TyMultipleResults pour refléter le fait que cette construction n'est pas une taille fixe. De plus, plusieurs résultats sont désormais correctement gérés à plus de endroits.
Diverses améliorations des dactylographies de LUA Build-Ins tirant parti des valeurs de retour variadiques, etc.
Nous pouvons maintenant taper toutes les propriétés des tables, pas seulement les constantes de chaîne. Étant donné que la luanalyse ajoute également le support pour les types littéraux primitifs, nous pouvons l'utiliser de nombreuses façons différentes.
Ici, nous avons des champs d'identification de chaîne régulières, des champs littéraux nombres [1] , [2] et [3] et un champ [boolean] . Ce dernier est vraiment puissant, car ce n'est pas une constante, c'est un vrai type.
Nous pouvons taper des structures de données personnalisées, par exemple
--- @class Dictionary < K , V >
--- @field [ K] V Cela fonctionnera correctement pour tout K et tout sera vérifié statiquement comme vous vous en doutez.
Il y a aussi une syntaxe pour les types de table, cela fonctionne pour les littéraux de table et les classes anonymes (c'est-à-dire des tables qui ne sont pas explicitement dactylographiées):
Nous prenons maintenant en charge les types fun avec des listes de paramètres facultatives et des valeurs de retour facultatives, c'est-à-dire fun: boolean et fun(arg: boolean) . fun (sans aucun spécifié) fonctionne également pour la postérité mais est fonctionnellement équivalent au type function existant.
Les fonctions partiellement typées sont extrêmement utiles pour implémenter les modèles de rappel et de gestionnaire. Par exemple, il est assez courant d'avoir un système d'événements extensible où chaque événement a des arguments uniques, mais le gestionnaire doit revenir true pour indiquer que l'événement a été géré:
C'est une autre fonctionnalité vraiment utile. Nous pouvons maintenant indiquer correctement qu'un objet est appelant (c'est-à-dire un table dont la métaTable a une méthode __call ).
Cela se fait en utilisant le mot-clé @overload Emmydoc existant, et fonctionne de manière similaire, c'est-à-dire que nous pouvons spécifier de nombreuses surcharges et la vérification et l'achèvement des types fonctionneront comme vous vous en doutez:
Les tuples peuvent être implémentés sous forme de formes avec des indices littéraux numériques:
ou comme alias des types de types de table:
Comme on peut le voir ci-dessus, lorsqu'un tuple est compatible avec un tableau, il peut être attribué à un, mais pas vice versa.
L'annotation @type prend en charge une liste de types. Cela peut être utilisé lors de la déclaration des variables:
ou pour couler plusieurs résultats renvoyés par une expression (par exemple, l'appel de fonction):
@not -type lance Un casting de type @not élimine les types d'un syndicat. Il est utile dans une variété de circonstances, dont la plus simple est d'éliminer nil :
Comme @type , prend également en charge les listes de types pour couler plusieurs valeurs de retour d'une fonction et peut lui-même éliminer les syndicats:
Lorsque vous souhaitez simplement éliminer les types d'un syndicat, il est généralement plus sûr d'utiliser @not Cast qu'un casting @type parce qu'un casting @type désactive essentiellement tous les types de vérification pour l'affectation, où @not cast exclut simplement certains types.
@type Annotations sur les déclarations de retourLes instructions de retour acceptent désormais les annotations de type, qui sont des moyens de type de type de type de la valeur de retour des lambdas anonymes.
Contrairement à un casting de type, ce sont des types de type:
Les types d'alias sont désormais résolus paresseusement, ce qui nous permet de taper des structures de données récursives. Par exemple, JSON:
Une API Fonctions peut renvoyer un nombre inconnu de résultats. Cependant, lorsque vous appelez ces fonctions, vous avez tendance à savoir combien de résultats vous attendez.
Une valeur de retour variadique peut être coulée sur une liste de types de béton par @not Casting Away nil :
Un type variatique peut également être jeté à un autre:
Nous prenons désormais en charge les paramètres facultatifs dans les définitions de type de fonction à court et longue forme, par exemple
Surtout, facultatif n'est pas une main courte pour nil | type .
Vous ne pouvez pas fournir nil sauf si le type de paramètre facultatif lui-même inclut nil dans le cadre d'une syndicat dans sa définition de type. Ceci est souhaitable à des fins d'exactitude lors de la mise en œuvre des fonctions dans LUA, disons par exemple si l'implémentation utilise [ select('#', …) ] (https://www.lua.org/manual/5.3/manual.html#pdf-select). Cependant, au-delà de cela, Lua est régulièrement utilisé comme langage de script, liant les appels de la fonction LUA aux implémentations dans d'autres langues qui ont une prise en charge des surcharges, etc. où le nombre et le type d'arguments sont importants.
Des inspections qui empêchent une commande de paramètres facultative incorrecte ont également été implémentées:
Construisez le plugin avec:
./gradlew buildPour plus de détails sur le SDK de la plate-forme JetBrains, veuillez vous référer à la documentation officielle.
Le plugin résultant .zip se retrouvera dans le répertoire ./build/distributions/ .
Pour installer le .zip que vous avez construit, vous devrez aller chez Intellij…
Préférences -> Plugins -> Paramètres Icône COG -> Installer le plugin à partir du disque ...
Sélectionnez le .zip , puis invité, redémarrez Intellij.
Luanalyse par: Benjamin Dobell
Emmylua par: @tangzx 阿唐
Contributeurs
Veuillez vous référer à GitHub pour une liste complète des contributeurs.
Merci aux sponsors et partisans de Luanalysis qui aident à assurer le développement continu de la luanalyse.
