Your IP : 216.73.216.213
E�Wq� � @ s� d Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l m Z d d l m
Z
d d l m Z m Z d d l
m Z d d l m Z d d l m Z m Z m Z m Z d d l m Z m Z m Z d d
l m Z m Z m 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 j# d d � � Z$ e d d d � � Gd d � d e � Z% d g Z& d d � Z' d d! d" � Z( d S)#z Code parsing for coverage.py.� N)�env)�range)�
bytes_to_ints� string_class)� CodeObjects)� short_stack)�contract� new_contract� nice_pair�
join_regex)�CoverageException�NoSource� NotPython)�compile_unicode�generate_tokens�neuter_encoding_declarationc @ s� e Z d Z d Z e d d � d d d d d � � Z e d d � � Z d d
� Z d d � Z d
d � Z
d d � Z d d � Z d d � Z
d d � Z d d � Z d d � Z d d � Z d d d � Z d S) � PythonParserz�Parse code to find executable lines, excluded lines, etc.
This information is all based on static analysis: no code execution is
involved.
�textz unicode|NoneNc C s7 | s | s t d � � | p! d | _ | | _ | j s� d d l m } y | | j � | _ Wn> t k
r� } z t d | j | f � � WYd d } ~ Xn X| | _ | j j d � | _ t
� | _ t
� | _ t
� | _
t
� | _ t
� | _ t
� | _ d | _ i | _ d | _ d | _ d | _ d S) z�
Source can be provided as `text`, the text itself, or `filename`, from
which the text will be read. Excluded lines are those that match
`exclude`, a regex.
z*PythonParser needs either text or filenamez<code>r )�get_python_sourcez No source for code: '%s': %sN�
F)�AssertionError�filenamer Zcoverage.pythonr �IOErrorr
�exclude�split�lines�set�
statements�excluded�raw_statements� raw_excluded�
raw_classdefs�raw_docstrings� show_tokens�
_multiline� _byte_parser� _all_arcs�_missing_arc_fragments)�selfr r r r �err� r* �B/opt/alt/python35/lib64/python3.5/site-packages/coverage/parser.py�__init__ s. ) zPythonParser.__init__c C s+ | j s$ t | j d | j �| _ | j S)z Create a ByteParser on demand.r )r% �
ByteParserr r )r( r* r* r+ � byte_parser\ s zPythonParser.byte_parserc G s� t | � } t j r$ | j d � } t j | � } t � } x? t | j d d �D]( \ } } | j | � rR | j
| � qR W| S)z�Find the lines matching one of a list of regexes.
Returns a set of line numbers, the lines that contain a match for one
of the regexes in `regexes`. The entire line needn't match, just a
part of it.
�utf8�start� ) r r �PY2�decode�re�compiler � enumerater �search�add)r( ZregexesZcombinedZregex_c�matches�i�ltextr* r* r+ �lines_matchingc s "zPythonParser.lines_matchingc C s� | j r | j | j � | _ d } d } d } d } t j } d } d } d } t | j � } xx| D]p\ }
} \ } }
\ } }
} | j r� t d t j
j |
|
� t | | f � | | f � |
t j k r� | d 7} n�|
t j
k r� | d 8} nl|
t j k r,| d k rj| j j | � n>|
t j k r�| d k r�| | j k pY| } | r�| r�| j j | � | } d } d } qj| d k rj| rj| | j k r�d } | rj| j j | � n� |
t j k r | t j k r | j j t | | d � � n^ |
t j k rj| d k r^| | k r^x( t | | d � D] } | | j | <qGWd } d } | j � r�|
t j k r�d } | d k r�| } | r�| | k r�d } | r�| j j | � d } |
} qg W| s�| j j | j j � � d S)
zwParse the source to find the interesting facts about its lines.
A handful of attributes are updated.
r FNTz%10s %5s %-20r %rr1 �class�:�@) r r< r �token�INDENTr r r# �print�tokenize�tok_name�getr
�DEDENT�NAMEr! r8 �OP�STRINGr" �updater �NEWLINEr$ �strip�COMMENTr r. �_find_statements)r( �indentZexclude_indentZ excludingZexcluding_decoratorsZ prev_toktype�
first_line�emptyZ
first_on_lineZtokgenZtoktypeZttextZslineno�_Zelinenor; Zshould_exclude�lr* r* r+ �
_raw_parsev sp (
zPythonParser._raw_parsec C s | j j | | � S)z?Return the first line number of the statement including `line`.)r$ rE )r( �liner* r* r+ rP � s zPythonParser.first_linec s t � f d d � | D� � S)z�Map the line numbers in `lines` to the correct first line of the
statement.
Returns a set of the first lines.
c 3 s | ] } � j | � Vq d S)N)rP )�.0rS )r( r* r+ � <genexpr>� s z+PythonParser.first_lines.<locals>.<genexpr>)r )r( r r* )r( r+ � first_lines� s zPythonParser.first_linesc C s
| j | � S)z)Implement `FileReporter.translate_lines`.)rX )r( r r* r* r+ �translate_lines� s z PythonParser.translate_linesc s � f d d � | D� S)z(Implement `FileReporter.translate_arcs`.c s4 g | ]* \ } } � j | � � j | � f � q Sr* )rP )rV �a�b)r( r* r+ �
<listcomp>� s z/PythonParser.translate_arcs.<locals>.<listcomp>r* )r( �arcsr* )r( r+ �translate_arcs� s zPythonParser.translate_arcsc C s� y | j � Wn} t j t f k
r� } zT t | d � rG | j } n | j d d } t d | j | j d | f � � WYd d } ~ Xn X| j | j
� | _ | j | j B} | j
| } | j | � | | _ d S)z�Parse source text to find executable lines, excluded lines, etc.
Sets the .excluded and .statements attributes, normalized to the first
line of multi-line statements.
�linenor1 r z5Couldn't parse '%s' as Python source: '%s' at line %dN)rT rC �
TokenError�IndentationError�hasattrr_ �argsr r rX r r r" r r )r( r) r_ �ignore�startsr* r* r+ � parse_source� s 0
zPythonParser.parse_sourcec C s | j d k r | j � | j S)z�Get information about the arcs available in the code.
Returns a set of line number pairs. Line numbers have been normalized
to the first line of multi-line statements.
N)r& � _analyze_ast)r( r* r* r+ r] s
zPythonParser.arcsc C s� t | j | j | j � } | j � t � | _ xW | j D]L \ } } | j | � } | j | � } | | k r; | j j | | f � q; W| j
| _ d S)zkRun the AstArcAnalyzer and save its results.
`_all_arcs` is the set of arcs in the code.
N) �AstArcAnalyzerr r r$ �analyzer r& r] rP r8 �missing_arc_fragmentsr' )r( Zaaa�l1�l2Zfl1Zfl2r* r* r+ rg s
zPythonParser._analyze_astc C s� t j t � } x[ | j � D]M \ } } | d k r7 q | | j k rI q | | j k r[ q | | d 7<q Wx+ | j D] } | | k rw | | d 8<qw W| S)zYGet a count of exits from that each line.
Excluded lines are excluded.
r r1 )� collections� defaultdict�intr] r r! )r( � exit_countsrk rl rS r* r* r+ rp s zPythonParser.exit_countsc C ss | j d k r | j � | } | rr | d k rr | | k rr | | f | k rr | | f | j k rr | | } } | j j | | f d g � } g } x� | D]� } | \ } } | d k r� | d k r� | | f | j k r� | j | | � Sd } n d } | j d | � } d j d | d | � }
| d k rU|
d j d
| j d | � � 7}
| j |
� q� Wd j | � S)
z5Provide an English sentence describing a missing arc.Nr z didn't jump to the function exitz didn't jump to line {lineno}r_ zline {start} {emsg}r0 �emsgz, because {smsg}�smsgz or )NN)r' rg rE �missing_arc_description�format�append�join) r( r0 �endZ
executed_arcsZ actual_startZfragment_pairsZmsgsZ
fragment_pairrr rq �msgr* r* r+ rs 8 s0
"z$PythonParser.missing_arc_description)�__name__�
__module__� __qualname__�__doc__r r, �propertyr. r< rT rP rX rY r^ rf r] rg rp rs r* r* r* r+ r s = [ r c @ s[ e Z d Z d Z e d d � d d d d � � Z d d � Z d d
� Z d d � Z d S)
r- z3Parse bytecode to understand the structure of code.r �unicodeNc C s� | | _ | r | | _ n` y t | | d � | _ WnD t k
rz } z$ t d | | j | j f � � WYd d } ~ Xn Xx5 d d d g D]$ } t | j | � s� t d � � q� Wd S)N�execz5Couldn't parse '%s' as Python source: '%s' at line %d� co_lnotab�co_firstlineno� co_constszlThis implementation of Python doesn't support code analysis.
Run coverage.py under CPython for this command.) r �coder � SyntaxErrorr rx r_ rb r )r( r r� r Zsynerr�attrr* r* r+ r, e s ,zByteParser.__init__c s& t � j � } � f d d � | D� S)z~Iterate over all the code objects nested within this one.
The iteration includes `self` as its first value.
c 3 s$ | ] } t � j d | �Vq d S)r� N)r- r )rV �c)r( r* r+ rW � s z+ByteParser.child_parsers.<locals>.<genexpr>)r r� )r( �childrenr* )r( r+ �
child_parsers} s zByteParser.child_parsersc c s� t | j j d d d � � } t | j j d d d � � } d } | j j } d } xT t | | � D]C \ } } | r� | | k r� | | f V| } | | 7} | | 7} qf W| | k r� | | f Vd S)a& Map byte offsets to line numbers in `code`.
Uses co_lnotab described in Python/compile.c to map byte offsets to
line numbers. Produces a sequence: (b0, l0), (b1, l1), ...
Only byte offsets that correspond to line numbers are included in the
results.
r N� r1 )r r� r� r� �zip)r( �byte_increments�line_incrementsZ
last_line_numZline_numZbyte_num� byte_incr� line_incrr* r* r+ � _bytes_lines� s
zByteParser._bytes_linesc c s= x6 | j � D]( } x | j � D] \ } } | Vq Wq
Wd S)z�Find the statements in `self.code`.
Produce a sequence of line numbers that start statements. Recurses
into all code objects reachable from `self.code`.
N)r� r� )r( ZbprR rS r* r* r+ rN � s zByteParser._find_statements) ry rz r{ r| r r, r� r� rN r* r* r* r+ r- b s r- c @ s" e Z d Z d Z d d � Z d S)� LoopBlockz@A block on the block stack representing a `for` or `while` loop.c C s | | _ t � | _ d S)N)r0 r � break_exits)r( r0 r* r* r+ r, � s zLoopBlock.__init__N)ry rz r{ r| r, r* r* r* r+ r� � s r� c @ s" e Z d Z d Z d d � Z d S)�
FunctionBlockz>A block on the block stack representing a function definition.c C s | | _ | | _ d S)N)r0 �name)r( r0 r� r* r* r+ r, � s zFunctionBlock.__init__N)ry rz r{ r| r, r* r* r* r+ r� � s r� c @ s( e Z d Z d Z d d d d � Z d S)�TryBlockz6A block on the block stack representing a `try` block.Nc C sF | | _ | | _ t � | _ t � | _ t � | _ t � | _ d S)N)�
handler_start� final_startr �
break_from�
continue_from� return_from�
raise_from)r( r� r� r* r* r+ r, � s zTryBlock.__init__)ry rz r{ r| r, r* r* r* r+ r� � s r� c s+ e Z d Z d Z d � f d d � Z � S)�ArcStartz�The information needed to start an arc.
`lineno` is the line number the arc starts from. `cause` is a fragment
used as the startmsg for AstArcAnalyzer.missing_arc_fragments.
Nc s t t | � j | | | � S)N)�superr� �__new__)�clsr_ �cause)� __class__r* r+ r� � s zArcStart.__new__)ry rz r{ r| r� r* r* )r� r+ r� � s r� ZArcz
lineno, cause� ArcStartsc C s t d d � | D� � S)Nc s s | ] } t | t � Vq d S)N)�
isinstancer� )rV �xr* r* r+ rW � s z<lambda>.<locals>.<genexpr>)�all)�seqr* r* r+ �<lambda>� s r� c
@ sy e Z d Z d Z e d d d e � d d � � Z d d � Z d d d
d � Z d d
� Z e d e
� d d � � Z d d � Z d d � Z
d d � Z d d � Z e d d d d d d d d d! d" d# d$ g � Z e d d% � d& d' � � Z e d d% � d d d( d) � � Z d* d+ � Z e d, d% � d- d. � � Z e d, d% � d/ d0 � � Z e d, d% � d1 d2 � � Z e d, d% � d3 d4 � � Z e d d% � d5 d6 � � Z e d d% � d7 d8 � � Z e Z e d d% � d9 d: � � Z e d d% � d; d< � � Z e Z e Z e Z e d d% � d= d> � � Z e d d% � d? d@ � � Z! e d d% � dA dB � � Z" e d d% � dC dD � � Z# dE dF � Z$ e d d% � dG dH � � Z% e d d% � dI dJ � � Z& e d d% � dK dL � � Z' e d d% � dM dN � � Z( e( Z) dO dP � Z* dQ dR � Z+ e+ Z, dS dT � Z- dU dV � Z. e. dW � Z/ e. dX � Z0 e. dY � Z1 e. dZ � Z2 e3 j4 rue. d[ � Z5 d S)\rh z>Analyze source text with an AST to find executable code paths.r r~ r c s� t j t | � � | _ t � f d d � | D� � | _ � | _ t t j j
d d � � r� t d j | j � � t d j | j � � t
| j � t � | _ t j t � | _ g | _ t t t j j
d d � � � | _ d S)Nc 3 s! | ] } � j | | � Vq d S)N)rE )rV rS )� multiliner* r+ rW � s z*AstArcAnalyzer.__init__.<locals>.<genexpr>ZCOVERAGE_ASTDUMPr zStatements: {}zMultiline map: {}ZCOVERAGE_TRACK_ARCS)�ast�parser � root_noder r r� ro �os�environrE rB rt �ast_dumpr] rm rn �listrj � block_stack�bool�debug)r( r r r� r* )r� r+ r, � s "
zAstArcAnalyzer.__init__c C sY xR t j | j � D]> } | j j } t | d | d � } | d k r | | � q Wd S)z�Examine the AST tree from `root_node` to determine possible arcs.
This sets the `arcs` attribute to be a set of (from, to) line number
pairs.
Z_code_object__N)r� �walkr� r� ry �getattr)r( �node� node_nameZcode_object_handlerr* r* r+ ri � s
zAstArcAnalyzer.analyzeNc C s� | j r8 t d j | | | | � � t t d d � � | j j | | f � | d k sf | d k r� | j | | f j | | f � d S)z@Add an arc, including message fragments to use if it is missing.z!
Adding arc: ({}, {}): {!r}, {!r}�limit� N)r� rB rt r r] r8 rj ru )r( r0 rw rr rq r* r* r+ �add_arc s zAstArcAnalyzer.add_arcc C s
t | j � S)z.Yield the blocks in nearest-to-farthest order.)�reversedr� )r( r* r* r+ �nearest_blocks s z AstArcAnalyzer.nearest_blocksZreturnsc C sC | j j } t | d | d � } | d k r8 | | � S| j Sd S)z}What is the right line number to use for this node?
This dispatches to _line__Node functions where needed.
Z_line__N)r� ry r� r_ )r( r� r� �handlerr* r* r+ �
line_for_node s
z AstArcAnalyzer.line_for_nodec C s | j | j � S)N)r� �value)r( r� r* r* r+ �
_line__Assign s z AstArcAnalyzer._line__Assignc C sU t j d k rJ | j rJ | j d d k r9 | j d j S| j d j Sn | j Sd S)N� � r )r� r� )r Z PYVERSION�keysr_ �values)r( r� r* r* r+ � _line__Dict! s
zAstArcAnalyzer._line__Dictc C s( | j r | j | j d � S| j Sd S)Nr )�eltsr� r_ )r( r� r* r* r+ � _line__List- s zAstArcAnalyzer._line__Listc C s% | j r | j | j d � Sd Sd S)Nr r1 )�bodyr� )r( r� r* r* r+ �
_line__Module3 s z AstArcAnalyzer._line__Module�Assign�Assert� AugAssign�DeleteZExec�Expr�Global�Import�
ImportFrom�Nonlocal�PassZPrintr� c C sZ | j j } t | d | d � } | d k r8 | | � St t | j | � d d �g � S)zhAdd the arcs for `node`.
Return a set of ArcStarts, exits from this node to the next.
Z _handle__Nr� )r� ry r� r r� r� )r( r� r� r� r* r* r+ �add_arcs? s
zAstArcAnalyzer.add_arcsc C s� | d k r t | g � } x} | D]u } | j | � } | j j | | � } | | j k r^ q" x' | D] } | j | j | | j � qe W| j | � } q" W| S)au Add arcs for the body of a compound statement.
`body` is the body node. `from_start` is a single `ArcStart` that can
be the previous line in flow before this body. `prev_starts` is a set
of ArcStarts that can be the previous line. Only one of them should be
given.
Returns a set of ArcStarts, the exits from this body.
N) r r� r� rE r r� r_ r� r� )r( r� �
from_start� prev_startsZ body_noder_ rP Z
prev_startr* r* r+ �
add_body_arcsQ s
z AstArcAnalyzer.add_body_arcsc C sH | j j } | d k r d S| d k rD t j rD | j d
k rD d Sd S) z Is this a compile-time constant?� NameConstant�NumT�Name�True�False�NoneF)r� r� )r� r� r� )r� ry r �PY3�id)r( r� r� r* r* r+ �is_constant_expri s z AstArcAnalyzer.is_constant_expr�exitsc C sm xf | j � D]X } t | t � r6 | j j | � Pq
t | t � r
| j d k r
| j j | � Pq
Wd S)z0Add arcs due to jumps from `exits` being breaks.N)r� r� r� r� rJ r� r� r� )r( r� �blockr* r* r+ �process_break_exitsz s z"AstArcAnalyzer.process_break_exitsc C s� x� | j � D]u } t | t � rS x* | D]" } | j | j | j | j � q) WPq
t | t � r
| j d k r
| j j
| � Pq
Wd S)z3Add arcs due to jumps from `exits` being continues.N) r� r� r� r� r_ r0 r� r� r� r� rJ )r( r� r� �xitr* r* r+ �process_continue_exits� s
z%AstArcAnalyzer.process_continue_exitsc C s� x� | j � D]� } t | t � r� | j d k rb x* | D]" } | j | j | j | j � q8 WPq� | j d k r� | j j | � Pq
t | t
� r
x: | D]2 } | j | j | j | j d j | j
� � q� WPq
Wd S)z0Add arcs due to jumps from `exits` being raises.Nz!didn't except from function '{0}')r� r� r� r� r� r_ r� r� r� rJ r� r0 rt r� )r( r� r� r� r* r* r+ �process_raise_exits� s
z"AstArcAnalyzer.process_raise_exitsc C s� x� | j � D]� } t | t � rE | j d k rE | j j | � Pq
t | t � r
x: | D]2 } | j | j | j | j
d j | j � � q[ WPq
Wd S)z1Add arcs due to jumps from `exits` being returns.Nz!didn't return from function '{0}')
r� r� r� r� r� rJ r� r� r_ r0 r� rt r� )r( r� r� r� r* r* r+ �process_return_exits� s
z#AstArcAnalyzer.process_return_exitsc C s8 | j | � } t | d d �} | j | g � t � S)Nr� z*the break on line {lineno} wasn't executed)r� r� r� r )r( r� �hereZ break_startr* r* r+ �_handle__Break� s z AstArcAnalyzer._handle__Breakc C s� | j | � } | j r� xB | j D]7 } | j | � } | | k r" | j | | � | } q" W| j | j d � } | j j | | � } x@ t | d | � D]+ } | | j k r� | j | | � | } q� Wt t | d d �g � S)zBAdd arcs for things that can be decorated (classes and functions).r r1 r� N)
r� Zdecorator_listr� r� r� rE r r r r� )r( r� �lastZdec_nodeZ dec_startZ
body_startr_ r* r* r+ �_handle_decorated� s
z AstArcAnalyzer._handle_decoratedc C s8 | j | � } t | d d �} | j | g � t � S)Nr� z-the continue on line {lineno} wasn't executed)r� r� r� r )r( r� r� Zcontinue_startr* r* r+ �_handle__Continue� s z AstArcAnalyzer._handle__Continuec C s� | j | j � } | j j t d | � � t | d d �} | j | j d | �} x' | D] } | j | j | | j
� q\ W| j j � } | j } t | d d �} | j
r� | j | j
d | �} | | O} n
| j | � | S)Nr0 r� z'the loop on line {lineno} never startedr� z)the loop on line {lineno} didn't complete)r� �iterr� ru r� r� r� r� r� r_ r� �popr� �orelser8 )r( r� r0 r� r� r� �my_block�
else_exitsr* r* r+ � _handle__For� s
zAstArcAnalyzer._handle__Forc C sn | j | j � } t | d d �} | j | j d | �} t | d d �} | | j | j d | �O} | S)Nr� z-the condition on line {lineno} was never truer� z.the condition on line {lineno} was never false)r� �testr� r� r� r� )r( r� r0 r� r� r* r* r+ � _handle__If� s zAstArcAnalyzer._handle__Ifc C s8 | j | � } t | d d �} | j | g � t � S)Nr� z*the raise on line {lineno} wasn't executed)r� r� r� r )r( r� r� Z raise_startr* r* r+ �_handle__Raise� s z AstArcAnalyzer._handle__Raisec C s8 | j | � } t | d d �} | j | g � t � S)Nr� z+the return on line {lineno} wasn't executed)r� r� r� r )r( r� r� Z return_startr* r* r+ �_handle__Return s z AstArcAnalyzer._handle__Returnc C s� | j r" | j | j d � } n d } | j rJ | j | j d � } n d } t d | d | � } | j j | � | j | � } | j | j d t | d d ��} | j r� d | _ | j r� t
g � | _ n
| j j � t
� } | j rsd } xv | j D]k } | j | � } | d k r5| j
| | � | } d }
t | d |
�} | | j | j d | �O} qW| j r�| j | j d | �} | | O} | j r�| j j � | | j B| j B| j B| j B} | j | j d | �} | j r| j | j | � }
| j |
� | j rD| j | j | � } | j | � | j ro| j | j | � } | j | � | j r�| j | j | � } | j | � | S)Nr r� r� r� r� z3the exception caught by line {lineno} didn't happenr� )�handlersr� � finalbodyr� r� ru r� r� r� r� r r� r� r� r� r� r� r� �_combine_finally_startsr� r� r� r� )r( r� r� r� Z try_blockr0 r� Z
handler_exitsZlast_handler_startZ handler_nodeZ
from_causer� Z
final_fromr� Zcontinue_exitsZ raise_exitsZ return_exitsr* r* r+ � _handle__Try s^ $
zAstArcAnalyzer._handle__Tryc sz g } x? t | � D]1 \ } � � d k r | j � j d | � � q Wd j | � � t � f d d � | D� � } | S)z4Helper for building the cause of `finally` branches.Nr_ z or c 3 s! | ] } t | j � � Vq d S)N)r� r_ )rV �ex)r� r* r+ rW a s z9AstArcAnalyzer._combine_finally_starts.<locals>.<genexpr>)�sortedru rt rv r )r( re r� Zcausesr_ r* )r� r+ r� Z s z&AstArcAnalyzer._combine_finally_startsc C s g | _ | j | � S)N)r� r� )r( r� r* r* r+ �_handle__TryExceptd s z!AstArcAnalyzer._handle__TryExceptc C s� g | _ g | _ | j d } | j j d k r� | j | j k r� t | j � d k s^ t � | j | _ | j | _ | j | _ | j | � S)Nr Z TryExceptr1 ) r� r� r� r� ry r_ �lenr r� )r( r� �firstr* r* r+ �_handle__TryFinallyl s
$ z"AstArcAnalyzer._handle__TryFinallyc
C s0 | j | j � } | j | j � } } | rD | j | j d � } | j j t d | � � t | d d �} | j | j d | �} x' | D] } | j | j
| | j � q� Wt � } | j j
� } | j | j � t | d d �} | j r| j | j d | �} | | O} n | s,| j | � | S)Nr r0 r� z-the condition on line {lineno} was never truer� z.the condition on line {lineno} was never false)r� r� r� r� r� ru r� r� r� r� r_ r� r r� rJ r� r� r8 )
r( r� Z
constant_testr0 Zto_topr� r� r� r� r� r* r* r+ �_handle__While} s&
z AstArcAnalyzer._handle__Whilec C s1 | j | � } | j | j d t | � �} | S)Nr� )r� r� r� r� )r( r� r0 r� r* r* r+ �
_handle__With� s z AstArcAnalyzer._handle__Withc C s� | j | � } | j rh | j | j d t | � �} xP | D]# } | j | j | | j d � q> Wn" | j | | � | j | | � d S)Nr� zdidn't exit the module)r� r� r� r� r� r_ r� )r( r� r0 r� r� r* r* r+ �_code_object__Module� s
$z#AstArcAnalyzer._code_object__Modulec C sn | j | � } | j j t d | d | j � � | j | j d t | � �} | j | � | j j � d S)Nr0 r� r� )
r� r� ru r� r� r� r� r� r� r� )r( r� r0 r� r* r* r+ �_code_object__FunctionDef� s
"
z(AstArcAnalyzer._code_object__FunctionDefc C s| | j | � } | j | | � | j | j d t | � �} x7 | D]/ } | j | j | | j d j | j � � qE Wd S)Nr� z#didn't exit the body of class '{0}') r� r� r� r� r� r_ r� rt r� )r( r� r0 r� r� r* r* r+ �_code_object__ClassDef� s
z%AstArcAnalyzer._code_object__ClassDefc s � f d d � } | S)zFA function to make methods for online callable _code_object__ methods.c sY | j | � } | j | | d d j � | � � | j | | d d j � | � � d S)Nz didn't run the {0} on line {1}z!didn't finish the {0} on line {1})r� r� rt )r( r� r0 )�nounr* r+ � _code_object__oneline_callable� s
#
zPAstArcAnalyzer._make_oneline_code_method.<locals>._code_object__oneline_callabler* )r r r* )r r+ �_make_oneline_code_method� s z(AstArcAnalyzer._make_oneline_code_method�lambdazgenerator expressionzdictionary comprehensionzset comprehensionzlist comprehension)6ry rz r{ r| r r r, ri r� r� ro r� r� r� r� r� Z
OK_TO_DEFAULTr� r� r� r� r� r� r� r� r� Z_handle__ClassDefr� r� Z_handle__AsyncForZ_handle__FunctionDefZ_handle__AsyncFunctionDefr� r� r� r� r� r� r� r� r Z_handle__AsyncWithr r Z _code_object__AsyncFunctionDefr r Z_code_object__LambdaZ_code_object__GeneratorExpZ_code_object__DictCompZ_code_object__SetCompr r� Z_code_object__ListCompr* r* r* r+ rh � sd !
K
rh �ctxc C s4 | d g f i t � g k p3 t | t t t f � S)z:Is `value` simple enough to be displayed on a single line?N)r r� r ro �float)r� r* r* r+ �_is_simple_value� s r
c C s d | } t | t j � s? t d j | | j j | � � d St | d d � } | d k rr d j | j � } n d } d j | | j j | � } d d � t j | � D� } | s� t d
j | � � n<t
| � d k r t | d d � r | d \ } } t d
j | | | � � n� t | � | d } x� | D]� \ } } d j | | � }
t | � r{t d j |
| � � q8t | t � r�t d j |
� � x | D] } t
| | d � q�Wt d j | � � q8t |
� t
| | d � q8Wt d
j | � � d S)z`Dump the AST for `node`.
This recursively walks the AST, printing a readable version.
� z{0}<{1} {2!r}>Nr_ z @ {0}� z
{0}<{1}{2}c S s. g | ]$ \ } } | t k r | | f � q Sr* )�SKIP_DUMP_FIELDS)rV r� r� r* r* r+ r\ � s z ast_dump.<locals>.<listcomp>z{0}>r1 r z{0} {1}: {2!r}>z z{0}{1}:z {0} {1!r}z{0} [� z{0}])r� r� �ASTrB rt r� ry r� r_ � iter_fieldsr� r
r� r� ) r� �depthrO r_ Zlinemark�headZ named_fields�
field_namer� Z next_indent�prefix�nr* r* r+ r� � s<
&
r� ))r| r� rm r� r4 r@ rC �coverager Zcoverage.backwardr r r Zcoverage.bytecoder Zcoverage.debugr Z
coverage.miscr r r
r r r
r Zcoverage.phystokensr r r �objectr r- r� r� r� �
namedtupler� rh r
r
r� r* r* r* r+ �<module> s6 " � LP "
� �