Your IP : 216.73.216.213

Current Path : /opt/alt/python35/lib/python3.5/site-packages/pyflakes/__pycache__/
Upload File :
Current File : //opt/alt/python35/lib/python3.5/site-packages/pyflakes/__pycache__/checker.cpython-35.opt-1.pyc



2tX^��@s�dZddlZddlZddlZddlZejdKkZejdLkZejdMkZejdNkZ	yej
dZWnek
r�dZYnXe
eer�dnd	��ZyddlZWnTek
r"ddlZd
ejjkrfej_edd��ej_YnXdd
lmZerHdd�Zndd�Zeridd�Zndd�Ze	r�ejejfZnejejejfZGdd�de �Z!dd�Z"de!�dd�Z#dd�Z$Gdd�de%�Z&Gdd�de&�Z'Gd d!�d!e%�Z(Gd"d#�d#e%�Z)Gd$d%�d%e'�Z*Gd&d'�d'e*�Z+Gd(d)�d)e*�Z,Gd*d+�d+e*�Z-Gd,d-�d-e,�Z.Gd.d/�d/e&�Z/Gd0d1�d1e&�Z0Gd2d3�d3e'�Z1Gd4d5�d5e'�Z2Gd6d7�d7e&�Z3Gd8d9�d9e �Z4Gd:d;�d;e4�Z5Gd<d=�d=e4�Z6Gd>d?�d?e4�Z7Gd@dA�dAe4�Z8GdBdC�dCe8�Z9dDdEdFgZ:dGdH�Z;GdIdJ�dJe%�Z<dS)Oz]
Main module.

Implement the central Checker class.
Also, it models the Bindings and Scopes.
�N���TFZ__builtin__�builtins�decorator_listcCs|jS)N)Z
decorators)�s�r�A/opt/alt/python35/lib/python3.5/site-packages/pyflakes/checker.py�<lambda> sr
)�messagescCstt|j�j��S)N)�strZunicode�__name__�upper)�
node_classrrr	�getNodeType&srcCs
|jj�S)N)r
r)rrrr	r*scCs`t|tjtjf�r%|jgSt|tj�r\|j|jgdd�|jD�SdS)NcSsg|]}|g�qSrr)�.0�hdlrrr	�
<listcomp>3s	z#getAlternatives.<locals>.<listcomp>)�
isinstance�ast�IfZ
TryFinally�bodyZ	TryExcept�orelse�handlers)�nrrr	�getAlternatives/s
rcCsWt|tj�r|jgSt|tj�rS|j|jgdd�|jD�SdS)NcSsg|]}|g�qSrr)rrrrr	r9s	z#getAlternatives.<locals>.<listcomp>)rrrrZTryrr)rrrr	r5s
c@s.eZdZdZdd�Zdd�ZdS)�_FieldsOrderzFix order of AST node fields.cCs^|j}d|kr!dj}n!d|kr9dj}n	dj}tt|d|dd��S)N�iterZ
generators�value�key�reverseT)�_fields�find�tuple�sorted)�selfr�fieldsZ	key_firstrrr	�_get_fieldsDs		z_FieldsOrder._get_fieldscCs|j|�||<}|S)N)r')r%rr&rrr	�__missing__Osz_FieldsOrder.__missing__N)r
�
__module__�__qualname__�__doc__r'r(rrrr	rAsrcCs5i}x(|D] }|j|d�d||<q
W|S)z|
    Simplest required implementation of collections.Counter. Required as 2.6
    does not have Counter in collections.
    r�)�get)�itemsZresults�itemrrr	�counterTs
r0ccs|xu||jD]f}||kr#qt||d�}t|tj�rO|Vqt|t�rx|D]}|VqeWqWdS)z�
    Yield all direct child nodes of *node*, that is, all fields that
    are nodes and all items of fields that are lists of nodes.
    N)�	__class__�getattrrrZAST�list)�node�omitZ
_fields_order�nameZfieldr/rrr	�iter_child_nodes_s
r7cCs�t|tj�r|jSttd�rAt|tj�rA|jSt|tj�rmtdd�|jD��St|tj	�r�|j
St|tj�r�td|�}ddddd	di}|j
|j|�Str�t|tj�r�|jSt�SdS)
N�Bytescss|]}t|�VqdS)N)�convert_to_value)r�irrr	�	<genexpr>usz#convert_to_value.<locals>.<genexpr>r/�TrueT�FalseF�None)rr�Strr�hasattrr8�Tupler#�eltsZNumr�Name�VariableKeyr-r6�PY33ZNameConstantr�UnhandledKeyType)r/�resultZconstants_lookuprrr	r9os&!r9c@sFeZdZdZdd�Zdd�Zdd�Zdd	�Zd
S)�Bindingar
    Represents the binding of a value to a name.

    The checker uses this to keep track of which names have been bound and
    which names have not. See L{Assignment} for a special type of binding that
    is checked with stricter rules.

    @ivar used: pair of (L{Scope}, node) indicating the scope and
                the node that this binding was last used.
    cCs||_||_d|_dS)NF)r6�source�used)r%r6rIrrr	�__init__�s		zBinding.__init__cCs|jS)N)r6)r%rrr	�__str__�szBinding.__str__cCs)d|jj|j|jjt|�fS)Nz#<%s object %r from line %r at 0x%x>)r1r
r6rI�lineno�id)r%rrr	�__repr__�s	zBinding.__repr__cCst|t�o|j|jkS)N)r�
Definitionr6)r%�otherrrr	�	redefines�szBinding.redefinesN)r
r)r*r+rKrLrOrRrrrr	rH�s

rHc@seZdZdZdS)rPz7
    A binding that defines a function or a class.
    N)r
r)r*r+rrrr	rP�srPc@seZdZdZdS)rFzS
    A dictionary key of a type that we cannot or do not check for duplicates.
    N)r
r)r*r+rrrr	rF�srFc@s:eZdZdZdd�Zdd�Zdd�ZdS)	rDzY
    A dictionary key which is a variable.

    @ivar item: The variable AST object.
    cCs|j|_dS)N)rNr6)r%r/rrr	rK�szVariableKey.__init__cCs"|j|jko!|j|jkS)N)r1r6)r%Zcomparerrr	�__eq__�szVariableKey.__eq__cCs
t|j�S)N)�hashr6)r%rrr	�__hash__�szVariableKey.__hash__N)r
r)r*r+rKrSrUrrrr	rD�srDcsaeZdZdZd�fdd�Zdd�Zdd�Zed	d
��Zdd�Z	�S)
�Importationz�
    A binding created by an import statement.

    @ivar fullName: The complete name given to the import statement,
        possibly including multiple dotted components.
    @type fullName: C{str}
    Ncs5|p	||_g|_tt|�j||�dS)N)�fullName�	redefined�superrVrK)r%r6rI�	full_name)r1rr	rK�s	zImportation.__init__cCs>t|t�r|j|jkSt|t�o=|j|jkS)N)r�SubmoduleImportationrWrPr6)r%rQrrr	rR�szImportation.redefinescCs|jjd�d|jkS)z.Return whether importation needs an as clause.�.r,���)rW�splitr6)r%rrr	�
_has_alias�szImportation._has_aliascCs/|j�r d|j|jfSd|jSdS)z5Generate a source statement equivalent to the import.zimport %s as %sz	import %sN)r_rWr6)r%rrr	�source_statement�szImportation.source_statementcCs)|j�r|jd|jS|jSdS)z#Return import full name with alias.z as N)r_rWr6)r%rrr	rL�szImportation.__str__)
r
r)r*r+rKrRr_�propertyr`rLrr)r1r	rV�srVcsXeZdZdZ�fdd�Z�fdd�Zdd�Zedd	��Z�S)
r[a�
    A binding created by a submodule import statement.

    A submodule import is a special case where the root module is implicitly
    imported, without an 'as' clause, and the submodule is also imported.
    Python does not restrict which attributes of the root module may be used.

    This class is only used when the submodule import is without an 'as' clause.

    pyflakes handles this case by registering the root module name in the scope,
    allowing any attribute of the root module to be accessed.

    RedefinedWhileUnused is suppressed in `redefines` unless the submodule
    name is also the same, to avoid false positives.
    cs9|jd�d}tt|�j||�||_dS)Nr\r)r^rYr[rKrW)r%r6rIZpackage_name)r1rr	rKszSubmoduleImportation.__init__cs5t|t�r|j|jkStt|�j|�S)N)rrVrWrYr[rR)r%rQ)r1rr	rRszSubmoduleImportation.redefinescCs|jS)N)rW)r%rrr	rLszSubmoduleImportation.__str__cCsd|jS)Nzimport )rW)r%rrr	r`sz%SubmoduleImportation.source_statement)	r
r)r*r+rKrRrLrar`rr)r1r	r[�s
r[csCeZdZd�fdd�Zdd�Zedd��Z�S)�ImportationFromNcsh||_|p||_|jd�r7||j}n|d|j}tt|�j|||�dS)Nr\)�module�	real_name�endswithrYrbrK)r%r6rIrcrdrZ)r1rr	rKs	zImportationFrom.__init__cCs/|j|jkr$|jd|jS|jSdS)z#Return import full name with alias.z as N)rdr6rW)r%rrr	rL!szImportationFrom.__str__cCsD|j|jkr,d|j|j|jfSd|j|jfSdS)Nzfrom %s import %s as %szfrom %s import %s)rdr6rc)r%rrr	r`(s
	z ImportationFrom.source_statement)r
r)r*rKrLrar`rr)r1r	rbsrbcsFeZdZdZ�fdd�Zedd��Zdd�Z�S)�StarImportationz3A binding created by a 'from x import *' statement.cs3tt|�jd|�|d|_||_dS)N�*z.*)rYrfrKr6rW)r%r6rI)r1rr	rK5s
zStarImportation.__init__cCsd|jdS)Nzfrom z	 import *)rW)r%rrr	r`<sz StarImportation.source_statementcCs$|jjd�r|jS|jSdS)Nr\)rWrer`r6)r%rrr	rL@szStarImportation.__str__)r
r)r*r+rKrar`rLrr)r1r	rf2srfcs(eZdZdZ�fdd�Z�S)�FutureImportationzs
    A binding created by a from `__future__` import statement.

    `__future__` imports are implicitly used.
    cs/tt|�j||d�||f|_dS)N�
__future__)rYrhrKrJ)r%r6rI�scope)r1rr	rKOszFutureImportation.__init__)r
r)r*r+rKrr)r1r	rhHsrhc@seZdZdZdS)�Argumentz3
    Represents binding a name as an argument.
    N)r
r)r*r+rrrr	rkTsrkc@seZdZdZdS)�
Assignmenta
    Represents binding a name with an explicit assignment.

    The checker will raise warnings for any Assignment that isn't used. Also,
    the checker does not consider assignments in tuple/list unpacking to be
    Assignments, rather it treats them as simple Bindings.
    N)r
r)r*r+rrrr	rlZsrlc@seZdZdS)�FunctionDefinitionN)r
r)r*rrrr	rmdsrmc@seZdZdS)�ClassDefinitionN)r
r)r*rrrr	rnhsrncs(eZdZdZ�fdd�Z�S)�
ExportBindinga
    A binding created by an C{__all__} assignment.  If the names in the list
    can be determined statically, they will be treated as names for export and
    additional checking applied to them.

    The only C{__all__} assignment that can be recognized is one which takes
    the value of a literal list containing literal strings.  For example::

        __all__ = ["foo", "bar"]

    Names which are imported and not otherwise used but appear in the value of
    C{__all__} will not have an unused import warning reported for them.
    cs�d|kr7t|tj�r7t|dj�|_n	g|_t|jtjtjf�r�x9|jjD]+}t|tj	�rk|jj
|j�qkWtt
|�j||�dS)N�__all__)rrZ	AugAssignr3�namesrZListrArBr?�appendrrYrorK)r%r6rIrjr4)r1rr	rK{s	zExportBinding.__init__)r
r)r*r+rKrr)r1r	rols
roc@s"eZdZdZdd�ZdS)�ScopeFcCs,|jj}d|t|�tj|�fS)Nz<%s at 0x%x %s>)r1r
rN�dictrO)r%Z	scope_clsrrr	rO�szScope.__repr__N)r
r)r*�
importStarredrOrrrr	rs�srsc@seZdZdS)�
ClassScopeN)r
r)r*rrrr	rv�srvcsOeZdZdZdZedddg�Z�fdd�Zdd	�Z�S)
�
FunctionScopezp
    I represent a name scope for a function.

    @ivar globals: Names declared 'global' in this function.
    FZ__tracebackhide__Z__traceback_info__Z__traceback_supplement__cs;tt|�j�|jj�|_d|_d|_dS)NF)rYrwrK�
alwaysUsed�copy�globals�returnValue�isGenerator)r%)r1rr	rK�s	zFunctionScope.__init__ccs^xW|j�D]I\}}|jr
||jkr
|jr
t|t�r
||fVq
WdS)zR
        Return a generator for the assignments which have not been used.
        N)r.rJrz�
usesLocalsrrl)r%r6�bindingrrr	�unusedAssignments�s

zFunctionScope.unusedAssignments)	r
r)r*r+r}�setrxrKrrr)r1r	rw�srwc@seZdZdS)�GeneratorScopeN)r
r)r*rrrr	r��sr�c@seZdZdZdZdS)�ModuleScopezScope for a module.TN)r
r)r*r+�_futures_allowedrrrr	r��sr�c@seZdZdZdS)�DoctestScopezScope for a doctest.N)r
r)r*r+rrrr	r��sr��__file__�__builtins__ZWindowsErrorcCs0t|d�r|jSt|d�r,|jSdS)NrNr6)r@rNr6)r4rrr	�getNodeName�sr�c@sNeZdZdZdZdZdZee�j	e
�Zej
jd�Zergejejd��[dddej
kd	d
�Zdd�Zd
d�Zdd�Zdd�Zedd��Zejdd��Zedd��Zdd�Zdd�Zedd�Zdd�Zd d!�Z d"d#�Z!d$d%�Z"d&d'�Z#d(d)�Z$d*d+�Z%d,d-�Z&d.d/�Z'd0d1�Z(dd2d3�Z)d4d5�Z*d6d7�Z+d8d9�Z,d:d;�Z-e.j/�j0Z1d<d=�Z2d>d?�Z3e)Z4Z5Z6Z7Z8Z9Z:Z;Z<Z=Z>Z?Z@ZAZBe3ZCe)ZDZEZFZGZHZIZJZKZLZMZNZOe3ZPZQZRZSe)ZTZUZVe3ZWZXZYZZZ[Z\e3Z]Z^Z_Z`ZaZbZcZdZeZfZgZhZiZjZkZlZmZnZoZpZqZrZsZtZuZvZwZxZye)ZzZ{Z|Z}d@dA�Z~dBdC�ZdDdE�Z�e�Z�dFdG�Z�e�rpe)ne�Z�e�Z�Z�dHdI�Z�dJdK�Z�e�Z�dLdM�Z�dNdO�Z�e�Z�Z�dPdQ�Z�e�Z�dRdS�Z�dTdU�Z�dVdW�Z�dXdY�Z�e�Z�dZd[�Z�d\d]�Z�d^d_�Z�e�Z�d`da�Z�dbdc�Z�dS)d�Checkera�
    I check the cleanliness and sanity of Python code.

    @ivar _deferredFunctions: Tracking list used by L{deferFunction}.  Elements
        of the list are two-tuples.  The first element is the callable passed
        to L{deferFunction}.  The second element is a copy of the scope stack
        at the time L{deferFunction} was called.

    @ivar _deferredAssignments: Similar to C{_deferredFunctions}, but for
        callables which are deferred assignment checks.
    rNFZPYFLAKES_BUILTINS�,z(none)ZPYFLAKES_DOCTESTcCs�i|_g|_g|_g|_g|_||_|rQ|jj|�|_||_t	�g|_
fg|_||_|j
|�|j|j�d|_|j|j�d|_|j
dd�=|j�|j�dS)Nr,)�
_nodeHandlers�_deferredFunctions�_deferredAssignments�
deadScopesr�filename�builtIns�union�withDoctestr��
scopeStack�exceptHandlers�root�handleChildren�runDeferred�popScope�checkDeadScopes)r%�treer�rr�rrr	rK�s(								
		
zChecker.__init__cCs-|jj||jdd�|jf�dS)a{
        Schedule a function handler to be called just before completion.

        This is used for handling function bodies, which must be deferred
        because code later in the file might modify the global scope. When
        `callable` is called, the scope at the time this is called will be
        restored, however it will contain any new bindings added to it.
        N)r�rrr��offset)r%�callablerrr	�
deferFunction�s	zChecker.deferFunctioncCs-|jj||jdd�|jf�dS)zl
        Schedule an assignment handler to be called just after deferred
        function handlers.
        N)r�rrr�r�)r%r�rrr	�deferAssignmentszChecker.deferAssignmentcCs7x0|D](\}}}||_||_|�qWdS)zV
        Run the callables in C{deferred} using their associated scope stack.
        N)r�r�)r%Zdeferred�handlerrjr�rrr	r�
s		zChecker.runDeferredcCs)t|j�dko(t|jdt�S)N�r,)�lenr�rr�)r%rrr	�_in_doctestszChecker._in_doctestcCs*tdd�|jD��s dS|jjS)Ncss|]}t|t�VqdS)N)rr�)rrjrrr	r;sz)Checker.futuresAllowed.<locals>.<genexpr>F)�allr�rjr�)r%rrr	�futuresAllowedszChecker.futuresAllowedcCs"t|jt�rd|j_dS)NF)rrjr�r�)r%rrrr	r�"scCs|jdS)Nr,r])r�)r%rrr	rj(sz
Checker.scopecCs|jj|jj��dS)N)r�rrr��pop)r%rrr	r�,szChecker.popScopecCs�x�|jD]�}t|t�r"q
|jd�}|rMt|t�rMd}|rtt|j�}|j|�}n
g}}|r|jr�t	j
j|j�dkr�x+|D]#}|j
tj|dj|�q�W|jrx,|j�D]}t|t�r�||_q�Wx�|j�D]�}t|t�r|jpF|j|k}|sttj}	|j
|	|jt|��xi|jD]^}
t|j|
�tj�r�tj}	n|r�q~n	tj}	|j
|	|
|j|j�q~WqWq
WdS)z�
        Look at scopes which have been fully examined and report names in them
        which were imported but unused.
        rpNz__init__.py)r�rrvr-ror�rq�
differenceru�os�path�basenamer��reportrZUndefinedExportrI�valuesrfrJrVr6ZUnusedImportrrX�	getParentr�For�ImportShadowedByLoopVar�RedefinedWhileUnused)r%rjZall_bindingZ	all_namesZ	undefinedr6r~rrJZmessgr4rrr	r�/sB


	
		zChecker.checkDeadScopescCs|jj|��dS)N)r�rr)r%Z
scopeClassrrr	�	pushScopeaszChecker.pushScopecOs#|jj||j||��dS)N)rrrr�)r%ZmessageClass�args�kwargsrrr	r�dszChecker.reportcCs8x1|j}t|d�rt|d�r|SqWdS)NrB�ctx)�parentr@)r%r4rrr	r�gs	 zChecker.getParentcCs�|||fks1t|d�o-t|d�r5dS||krE|S|j|jkrm|j|j||�S|j|jkr�|j||j|�S|j|j|j|�S)Nr�)r@�depth�getCommonAncestorr�)r%�lnode�rnode�stoprrr	r�ns!zChecker.getCommonAncestorcCs.x'|D]}|j|||�rdSqWdS)NTF)r�)r%r4Z	ancestorsr��arrr	�descendantOf{s
zChecker.descendantOfcCsk|j|||j�}t|�}|rgx:|D]2}|j|||�|j|||�Ar1dSq1WdS)zATrue, if lnode and rnode are located on different forks of IF/TRYTF)r�r�rr�)r%r�r�Zancestor�partsr.rrr	�differentForks�s
zChecker.differentForkscCs�x.|jddd�D]}|j|krPqW|j|j�}|r�|j||j�r�|j|j�}t|t�r�t|tj	�r�|j
tj||j|j�n�||j
krZt|tj�rt|j|j�tj	tjf�r|j
tj||j|j�q�|jr�|j|�r�|j
tj||j|j�n.t|t�r�|j|�r�|jj|�|j|j
kr�|j
|jj|_||j
|j<dS)z�
        Called when a binding is altered.

        - `node` is the statement responsible for the change
        - `value` is the new value, a Binding instance
        Nr,r])r�r6r-r�rIr�rrVrr�r�rr�rj�
comprehensionZRedefinedInListComprJrRr�rXrr)r%r4rrjZexisting�parent_stmtrrr	�
addBinding�s.!zChecker.addBindingcCsNy|j|SWntk
r/t|�}YnXt||�|j|<}|S)N)r��KeyErrorrr2)r%rZnodeTyper�rrr	�getNodeHandler�s
zChecker.getNodeHandlercCs�t|�}|sdSd}d}x�|jddd�D]�}|dkr]t|t�r]q9y|j|f||_Wntk
r�YnXdS|p�|j}|dk	r9t|t�}q9W||j	kr�dS|rxg}xf|jd	dd
�D]N}xE|j
�D]7}t|t�r|j|f|_|j|j
�qWq�Wdjt|��}|jtj|||�dS|dkr�tjj|j�dkr�dSd|jdkr�|jtj||�dS)Nr,Fz, �__path__z__init__.py�	NameErrorr]r]r]r]r])r�r�rrvrjrJr�rur�r�r�rfrrrW�joinr$r�rZImportStarUsager�r�r�r�r��
UndefinedName)r%r4r6Z
in_generatorsrurj�	from_listr~rrr	�handleNodeLoad�s@
'zChecker.handleNodeLoadcCs�t|�}|sdSt|jt�r�||jkr�x�|jdd�D]�}t|ttf�siqK||ko||j}|rK|d|jkrK||jjkrK|jt	j
||jd|||j�PqKW|j|�}t|t
jt
jf�s&||jkr8|j|�r8t||�}nH|dkrqt|jt�rqt||j|j�}nt||�}|j||�dS)Nr,rrpr])r�rrjrwr�r�rJrzr�rZUndefinedLocalrIr�rr�r�r��isLiteralTupleUnpackingrHrorlr�)r%r4r6rjrJr�r~rrr	�handleNodeStore�s*!+zChecker.handleNodeStorecs��fdd�}t��}|s(dS|�r5dSt|jt�ro||jjkro|jjj|�n9y|j|=Wn(tk
r�|jtj	�|�YnXdS)NcsZt�dd�}xA|rUt|tjtjtjf�r@dSt|dd�}qWdS)zN
            Return `True` if node is part of a conditional body.
            r�NTF)r2rrr�WhileZIfExp)Zcurrent)r4rr	�on_conditional_branchs	!z7Checker.handleNodeDelete.<locals>.on_conditional_branch)
r�rrjrwrz�remover�r�rr�)r%r4r�r6r)r4r	�handleNodeDeletes	$
zChecker.handleNodeDeletecCs1x*t|d|�D]}|j||�qWdS)Nr5)r7�
handleNode)r%r�r5r4rrr	r�.szChecker.handleChildrencCsKt|tj�rGx.|j|jgD]}t|d�s&dSq&WdSdS)NrBFT)rrZAssign�targetsrr@)r%r4�childrrr	r�2s
zChecker.isLiteralTupleUnpackingcCs7t|tj�p6t|tj�o6t|jtj�S)z}
        Determine if the given node is a docstring, as long as it is at the
        correct place in the node tree.
        )rrr?�Exprr)r%r4rrr	�isDocstring9s$zChecker.isDocstringcCsqt|tj�r|j}t|tj�s1dStrG|jd}n|j|jjd�d}|j|fS)Nr,�
)NN)	rrr�rr?�PYPYrMr�count)r%r4Zdoctest_linenorrr	�getDocstringAs	zChecker.getDocstringcCs8|dkrdS|jr]t|dd�dk	r]|j|jd7_|j|jd7_|jr�td|j|jj�|j	r�t
|tj�p�|j
|�r�d|_	|jd7_|j|_||_z |j|j�}||�Wd|jd8_X|jr4td|jd|jj�dS)NrMrr,z  Fzend )r�r2rM�
col_offset�	traceTree�print�	nodeDepthr1r
r�rrZ
ImportFromr�r�r�r�)r%r4r�r�rrr	r�Os&!				zChecker.handleNodecCs�y5|j|jd�\}}|o1|j|�}Wnttfk
rSdSYnX|s^dS|j}|jdg|_|jp�d}|jt�d|j	k}|s�|j	j
d�x�|D]�}yt|jddt
j�}	Wn{tk
rdtj�d}
tr|
jd7_||j|
j|jd|
jpCdf}|jtj||�Yq�X|d||j|d|jdf|_|j|	�||_q�W|s�|j	jd�|j�||_dS)Nr�_z	<doctest>�execr,r)rr)r�r�_getDoctestExamples�
ValueError�
IndexErrorr�r�r�r�r��add�compilerIrZ
PyCF_ONLY_AST�SyntaxError�sys�exc_infor�rM�indentr�rZDoctestSyntaxErrorr�r�r�)r%r4Z	docstringZnode_linenoZexamplesZsaved_stackZnode_offsetZunderscore_in_builtinsZexampler��eZpositionrrr	�handleDoctestsgs@		





zChecker.handleDoctestscCsdS)Nr)r%r4rrr	�ignore�szChecker.ignorec	sdd��jD�}t|�}dd�|j�D�}x�|D]���fdd�t|�D�}t�fdd�|D��}tdd�|j�D��rBx\|D]T}�j|}t�t�r�|jtj	|�j
�q�|jtj|��q�WqBW|j��dS)NcSsg|]}t|��qSr)r9)rrrrr	r�s	z Checker.DICT.<locals>.<listcomp>cSs(g|]\}}|dkr|�qS)r,r)rrr�rrr	r�s		cs(g|]\}}|�kr|�qSrr)rr:Zi_key)rrr	r�s	c3s"|]}t�j|�VqdS)N)r9r�)r�index)r4rr	r;�szChecker.DICT.<locals>.<genexpr>css!|]\}}|dkVqdS)r,Nr)rrr�rrr	r;�s)
�keysr0r.�	enumerate�anyrrDr�rZMultiValueRepeatedKeyVariabler6ZMultiValueRepeatedKeyLiteralr�)	r%r4r�Z
key_countsZduplicate_keysZkey_indicesr�Z	key_indexZkey_noder)rr4r	�DICT�s(




zChecker.DICTcCsKt|jtj�r:|jjgkr:|jtj|�|j|�dS)N)	rZtestrrArBr�rZAssertTupler�)r%r4rrr	�ASSERT�s'zChecker.ASSERTcs�|j�rdnd}|j|}|j|k	r�x�|jD]�t�|�}�fdd�|jD�|_|j�|�||f|_x)|j|dd�D]}||�<q�Wq>WdS)z5
        Keep track of globals declarations.
        r,rcs<g|]2}t|tj�s2|jd�kr|�qS)r)rrr�Zmessage_args)r�m)�	node_namerr	r�s	z"Checker.GLOBAL.<locals>.<listcomp>N)r�r�rjrqrlr�
setdefaultrJ)r%r4Zglobal_scope_indexZglobal_scopeZ
node_valuerjr)r�r	�GLOBAL�s
zChecker.GLOBALcCs(|jt�|j|�|j�dS)N)r�r�r�r�)r%r4rrr	�GENERATOREXP�s

zChecker.GENERATOREXPcCs�t|jtjtjf�rp|j|�|jdkr�t|jt�r�t|j	tj
�r�d|j_nit|jtjtj
f�r�|j|�n;t|jtj�r�|j|�ntd|jf��dS)zV
        Handle occurrence of Name (which can be a load/store/delete access.)
        �localsTz%Got impossible expression context: %rN)rr�rZLoadZAugLoadr�rNrjrwr�ZCallr}�StoreZAugStorer�ZDelr��RuntimeError)r%r4rrr	�NAMEs
!zChecker.NAMEcCs�|}x�t|d�r�|j|}}t|t�rJ||jkrJdSt|tjtjf�rfPt|d�r	t|tj�r	||j	kr	|j
tj|�dSq	Wt|tj�r�|j
tj
|�n|j
tj|�dS)Nr��	finalbody)r@r�r�
LOOP_TYPESrr�FunctionDef�ClassDefZContinuer�r�rZContinueInFinallyZContinueOutsideLoopZBreakOutsideLoop)r%r4rZn_childrrr	�CONTINUEs!zChecker.CONTINUEcCs}t|jttf�r/|jtj|�dS|jrft|jd�rf|jj	rf|j|j_	|j
|j|�dS)Nr{)rrjrvr�r�rZReturnOutsideFunctionrr@r{r�)r%r4rrr	�RETURN-s	
zChecker.RETURNcCsRt|jttf�r/|jtj|�dSd|j_|j|j	|�dS)NT)
rrjrvr�r�rZYieldOutsideFunctionr|r�r)r%r4rrr	�YIELD:s
z
Checker.YIELDcs�x!�jD]}�j|��q
W�j���j�t�j����jr��j�r�t�j	t
�r��j��fdd��dS)Ncs
�j��S)N)r�r)r4r%rr	r
Nsz%Checker.FUNCTIONDEF.<locals>.<lambda>)rr��LAMBDAr�rmr6r�r�rrjrwr�)r%r4�decor)r4r%r	�FUNCTIONDEFDs
	
zChecker.FUNCTIONDEFcsg�g}trF��fdd����jj��jj}nWx>�jj�jjD]&}�j|j�|j|j�q]W�jj�jj}t�d�}x�d	D]}t	�j|�}|s�q��jt
r�|n|j�|r�t
r"|d}|jt	�j|��q�|j|j�q�W|rL|j�j�tt
���t��kr�xFt��D]8\}	}|�d|	�krw�jtj�|�qwWx(||D]}
|
r��j|
��q�W���fdd�}�j|�dS)
NcsGx@|D]8}t|tj�r/�|j�q�j|j�qWdS)N)rrrArBrrrN)Zarglist�arg)�addArgsr�rr	rWs
zChecker.LAMBDA.<locals>.addArgs�returns�vararg�kwarg�
annotationcs��j�x'�D]}�j�t|���qWt�jt�rmx7�jD]}�j|��qPWn�j�j���fdd�}�j|�tr��fdd�}�j|��j	�dS)Ncs=x6�jj�D]%\}}�jtj|j|�qWdS)zU
                Check to see if any assignments have not been used.
                N)rjrr�rZUnusedVariablerI)r6r~)r%rr	�checkUnusedAssignments�szCChecker.LAMBDA.<locals>.runFunction.<locals>.checkUnusedAssignmentscs5�jjr1�jjr1�jtj�jj�dS)z�
                    Check to see if there is any return statement with
                    arguments but the function is a generator.
                    N)rjr|r{r�rZReturnWithArgsInsideGeneratorr)r%rr	�&checkReturnWithArgumentInsideGenerator�szSChecker.LAMBDA.<locals>.runFunction.<locals>.checkReturnWithArgumentInsideGenerator)
r�r�rkrrr3r�r��PY32r�)r6�stmtrr	)r�r4r%rr	�runFunction�s



z#Checker.LAMBDA.<locals>.runFunction)rr)�PY2r��defaultsZ
kwonlyargsrrrrZkw_defaultsr@r2rErr�r�r�r�rZDuplicateArgumentr�r�)r%r4ZannotationsrrZis_py3_funcZarg_nameZwildcardZ
argannotation�idxr�rr)rr�r4r%r	r�Rs@

!zChecker.LAMBDAcsx!�jD]}�j|��q
Wx!�jD]}�j|��q.Wtsrx!�jD]}�j|��qXW�jt��jr��j�r�t	�j
t�r��j��fdd��x!�j
D]}�j|��q�W�j��j�t�j���dS)z�
        Check names used in a class definition, including its decorators, base
        classes, and the body of its definition.  Additionally, add its name to
        the current scope.
        cs
�j��S)N)r�r)r4r%rr	r
�sz"Checker.CLASSDEF.<locals>.<lambda>N)rr��basesr
�keywordsr�rvr�r�rrjrwr�rr�r�rnr6)r%r4rZbaseNodeZkeywordNoderr)r4r%r	�CLASSDEF�s 
	

zChecker.CLASSDEFcCs:|j|j�|j|j|�|j|j|�dS)N)r��targetr�r)r%r4rrr	�	AUGASSIGN�szChecker.AUGASSIGNcCs�tr�t|jtj�r�d}d}xUt|j�D]D\}}t|tj�r8|rp|jt	j
|�Pd}|}q8W|dks�t|j�|ddkr�|jt	j|�|j
|�dS)	NFr,T��r]�i)r
rr�rr�r�rBZStarredr�rZTwoStarredExpressionsr�Z%TooManyExpressionsInStarredAssignmentr�)r%r4Zhas_starredZstar_locr:rrrr	�TUPLE�s
)z
Checker.TUPLEcCs}xv|jD]k}d|jkr>|jr>t|j|�}n'|jpM|j}t|||j�}|j||�q
WdS)Nr\)rqr6�asnamer[rVr�)r%r4�alias�importationr6rrr	�IMPORT�szChecker.IMPORTcCs~|jdkrA|jsJ|jtj|dd�|jD��n	d|_d|j|jp`d}x|jD]}|jp�|j}|jdkr�t	|||j
�}|jtjkrf|jtj
||j�n�|jdkrNtrt|j
t�r|jtj||�qnd|j
_|jtj||�t||�}nt||||j�}|j||�qnWdS)	NricSsg|]}|j�qSr)r6)rrrrr	r�s	z&Checker.IMPORTFROM.<locals>.<listcomp>Fr\�rgT)rcr�r�rZLateFutureImportrq�levelrr6rhrjriZall_feature_namesZFutureFeatureNotDefinedr
rr�ZImportStarNotPermittedruZImportStarUsedrfrbr�)r%r4rcrr6rrrr	�
IMPORTFROM�s0		
	zChecker.IMPORTFROMcCsg}x�t|j�D]�\}}t|jtj�rdxI|jjD]}|jt|��qDWn|jr�|jt|j��|jdkr|t	|j�dkr|j
tj|�qW|j
j|�x!|jD]}|j||�q�W|j
j�|j|dd�dS)Nr,r5r)r�rr�typerrArBrrr�r�r�rZDefaultExceptNotLastr�rr�r�r�)r%r4Z
handler_namesr:r��exc_typer�rrr	�TRYs	(
zChecker.TRYcCs�ts|jdkr&|j|�dSx:|jddd�D]}|j|kr=d}Pq=Wd}|j|�|j|�|s�y|j|j=Wntk
r�YnXdS)Nr,TFr])r
r6r�r�r�rjr�)r%r4rjZis_name_previously_definedrrr	�
EXCEPTHANDLERs



zChecker.EXCEPTHANDLERcCsa|jr|j|j|�t|jt�sA|j|j|�|jr]|j|j|�dS)z�
        Annotated assignments don't have annotations evaluated on function
        scope, hence the custom implementation.

        See: PEP 526.
        N)rr�rrrjrwr)r%r4rrr	�	ANNASSIGN;s		zChecker.ANNASSIGN)�r
r)r*r+r�r�r�r��builtin_varsr��_MAGIC_GLOBALSr�r��environr-Z_customBuiltIns�updater^rKr�r�r�r�rar��setterrjr�r�rwr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r��doctestZ
DocTestParserZget_examplesr�r�r�ZDELETEZPRINTZFORZASYNCFORZWHILEZIFZWITHZWITHITEMZ	ASYNCWITHZ
ASYNCWITHITEMZRAISEZ
TRYFINALLYZEXECZEXPRZASSIGNZPASSZBOOLOPZBINOPZUNARYOPZIFEXPZSETZCOMPARE�CALLZREPRZ	ATTRIBUTEZ	SUBSCRIPTZSTARREDZNAMECONSTANTZNUMZSTRZBYTES�ELLIPSISZSLICEZEXTSLICEZINDEXZLOADZSTOREZDELZAUGLOADZAUGSTOREZPARAMZAND�ORZADDZSUBZMULTZDIVZMODZPOWZLSHIFTZRSHIFTZBITORZBITXORZBITANDZFLOORDIVZINVERTZNOTZUADDZUSUBZEQZNOTEQZLTZLTEZGTZGTEZISZISNOT�INZNOTINZMATMULTZ
COMPREHENSIONZKEYWORDZFORMATTEDVALUEZ	JOINEDSTRr�r�r�ZNONLOCALr�r
ZLISTCOMPZDICTCOMPZSETCOMPr�r�ZBREAKr�r��AWAITZ	YIELDFROMrZASYNCFUNCTIONDEFr�rrrZLISTrrr"Z	TRYEXCEPTr#r$rrrr	r��s�	2
'6'>2v$


Q	 "r�)rr)rr)rr)rr)=r+rir*r�r��version_infor
r
rEZPY34Zpypy_version_infor��AttributeError�dir�
__import__r%r�ImportErrorZ_astr�r!rrar�Zpyflakesrrrr�r�r�ZAsyncForrtrr0r7r9�objectrHrPrFrDrVr[rbrfrhrkrlrmrnrorsrvrwr�r�r�r&r�r�rrrr	�<module>st


(%