static typing

statique

Augument Python 3 Arbres de syntaxe abstraits (AST) avec des informations de type statique.

Python est un langage de programmation dynamiquement typé. Cependant, une grande partie du code Python généralement vu fonctionnerait même si elle était typiquement typique!

Avec ce package, on peut insérer des informations de type statique dans les arbres de syntaxe abstraits Python (AST), donc en supposant que le code donné fonctionnerait si Python était typiquement typique, on peut raisonner sur les types du code statiquement, avant l'exécution.

Un tel AST augmenté est principalement destiné à l'analyse / consommation à l'aide d'autres outils.

Fonctionne mieux avec les AST du module typed_ast , mais il fonctionne également avec le module ast intégré.

Soyez informé qu'il s'agit d'un travail continu et que la mise en œuvre actuelle est soumise à des changements soudains.

La prise en charge de typed_ast sera abandonnée après la libération de Python 3.8, car sa fonctionnalité sera fusionnée dans l'analyseur AST intégré.

Contenu

• Comment utiliser
  • Manipulation AST
• Comment il est mis en œuvre
  • Résolution de moindre indice
  • Type d'informations combinées
  • Réécriture AST
• Exigences

Comment utiliser

Vous pouvez utiliser le module static_typing pour analyser le code directement à l'aide de la fonction parse() :

 import static_typing as st
class MyClass :
    pass
module = st . parse ( 'def my_fun(obj: MyClass) -> MyClass: return obj' )
# TODO: currently there is no public API yet
functions = module . _functions
my_fun = module . _functions [ 'my_fun' ]
assert MyClass in my_fun . _params [ 'obj' ]

Ou, vous pouvez augmenter la fonction AST existante en utilisant augment() :

 import static_typing as st
import typed_ast . ast3
module = typed_ast . ast3 . parse ( '''def spam(): x, y, z = 'ham', 42, 3.1415  # type: str, int, float''' )
module = st . augment ( module )
# TODO: currently there is no public API yet
function = module . _functions [ 'spam' ]
assert len ( function . _local_vars ) == 3
assert float in function . _local_vars [ 'z' ]

Pour plus d'exemples, voir Exemples.Ipynb Notebook.

Manipulation AST

De plus, aux principales caractéristiques, la bibliothèque contient le module static_typing.ast_manipulation qui contient des outils de bas niveau et des blocs de construction permettant:

• Transfert récursif AST,
• Validation AST,
• transformations AST récursives,
• AST transcrit (de typed_ast à ast intégré et vice versa) et
• Résoudre des indices de type (décrit en détail ci-dessous).

Comment il est mis en œuvre

Le processus ou le typage statique, que la fonction augment() implémente, a 3 étapes principales:

• Tapez la résolution des indices,
• Tapez des informations combinées et
• Réécriture AST.

Résolution de moindre indice

Dans tous les nœuds applicables, les astuces de type sont stockées dans Fields type_comment , annotation and returns . Le resolver de type indication lit ces champs - que les isolent sont soit des cordes brutes ou des AST.

Il utilise des tables de symboles Python fournies pour résoudre les conseils de type dans des objets de type réel en utilisant l'introspection.

Par défaut, le résolver utilise uniquement des symboles intégrés lorsqu'il est appelé directement ou via augment() . Cependant, lorsqu'il est appelé via parse() il utilise par défaut globals() et locals() de l'appelant.

Les indices de type résolu sont stockés directement dans l'AST. Plus précisément, chaque champ résolu est stocké dans un champ nommé en conséquence, qui est soit resolved_type_comment , resolved_annotation ou resolved_returns .

Ainsi, les informations de type statique deviennent disponibles dans l'AST.

Type d'informations combinées

Pour chaque nœud AST qui pourrait contenir des déclarations de nom, une version exetend d'un nœud est fournie. Chaque nœud AST étendu a de nouveaux champs qui stockent les noms déclarés et tapent des informations associées à chaque nom.

Ces nouveaux champs stockent toutes les informations de type de tous les conseils de type résolu dans toute portée locale, de sorte qu'un conflit de type ou un manque d'informations de type puisse être détecté. De plus, en fonction de ces informations combinées, l'inférence de type peut être effectuée.

Plus précisément, de nouvelles versions des nœuds AST suivantes avec de nouveaux champs sont fournies: Module , FunctionDef , ClassDef , Assign , AnnAssign , For et With . Ces nouvelles versions ont leurs noms préfixés StaticallyTyped...

Une liste d'entités pour lesquelles les informations sont recueillies dans ces nouveaux domaines suit.

Pour Module :

• variables définies
• fonctions définies
• classes définies

Pour FunctionDef :

• paramètres et leurs types
• types de retour
• KIND (FONCTION IE, MÉTHODE D'INNEMPLE, MÉTHODE DE CLASSE, MÉTHODE STATIQUE, ETC.)
• Variables locales et leurs types

Pour ClassDef :

• Méthodes définies (toutes ensemble et regroupées par genre)
• champs de classe et leurs types
• champs d'instance et leurs types

Pour Assign et AnnAssign :

• cibles d'affectation et leurs types

Pour For :

• Variables d'index et leurs types

Pour With :

• Variables de contexte et leurs types

Réécriture AST

La réécriture AST signifie remplacer les nœuds AST ordinaires répertoriés ci-dessus par leurs versions étendues.

Exigences

Python Version 3.5 ou version ultérieure.

Bibliothèques Python comme spécifié dans exigences.txt.

La construction et l'exécution de tests nécessitent en outre des packages répertoriés dans test_requiments.txt.

Testé sur Linux et Windows.