B `@sdZddlZddlZddlZddlZddlZddlZddlmZddl m Z ddl m Z m Z ddl mZddlmZddlmZmZmZmZmZdd lmZmZmZdd lmZmZmZGd d d eZGd ddeZ GdddeZ!GdddeZ"GdddeZ#Gddde$ddZ%eddde&e'ej()ddZ*GdddeZ+Gdd d eZ,e*rd!gZ-d"d#Z.d&d$d%Z/dS)'zCode parsing for coverage.py.N)env)range) bytes_to_ints string_class) code_objects) short_stack)contract join_regex new_contract nice_pairone_of)NoSource NotPythonStopEverything)compile_unicodegenerate_tokensneuter_encoding_declarationc@seZdZdZedddddZeddZd d Zd d Z d dZ ddZ ddZ ddZ ddZddZddZddZd ddZdS)! PythonParserzParse code to find executable lines, excluded lines, etc. This information is all based on static analysis: no code execution is involved. z unicode|None)textNc Cs|s|std|pd|_||_|jsxddlm}y||j|_Wn4tk rv}ztd|j|fWdd}~XYnX||_|jd|_ t |_ t |_ t |_ t |_t |_t |_d|_i|_d|_d|_d|_dS) 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 filenamezr)get_python_sourcezNo source for code: '%s': %sN F)AssertionErrorfilenamerZcoverage.pythonrIOErrorr excludesplitlinesset statementsexcludedraw_statements raw_excluded raw_classdefsraw_docstrings show_tokens _multiline _byte_parser _all_arcs_missing_arc_fragments)selfrrrrerrr+W/home/kop/projects/devel/pgwui/test_venv/lib/python3.7/site-packages/coverage/parser.py__init__s.  "zPythonParser.__init__cCs|jst|j|jd|_|jS)zCreate a ByteParser on demand.)r)r& ByteParserrr)r)r+r+r, byte_parser\szPythonParser.byte_parsercGs\t|}tjr|d}t|}t}x.t|jddD]\}}| |r8| |q8W|S)zFind 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 rPY2decoderecompiler enumeratersearchadd)r)ZregexesZcombinedZregex_cmatchesiltextr+r+r,lines_matchingcs   zPythonParser.lines_matchingcCsj|jr||j|_d}d}d}d}tj}d}d}d}t|j} x| D]\} } \} } \}} }|jrtdt j | | t | |f| |f| tjkr|d7}n0| tj kr|d8}n| tjkr| dkr|j| n| tjkrV| dkr"||jkp|}|sT|rT|j||}d}d}n2| d kr|r||jkrBd}|r|j|n|| tjkr|tjkr|jt| |dnL| tjkr|dk r||krx"t||dD]}||j|<qWd}d}| r$| t jkr$d}|dkr$| }|r||krd}|r |j|d}| }qHW|sD|j|jtjjrf|jrft |j|jd<dS) zwParse the source to find the interesting facts about its lines. A handful of attributes are updated. rFNTz%10s %5s %-20r %rr1class:@)!rr=r!tokenINDENTrrr$printtokenizetok_namegetr DEDENTNAMEr"r9OPSTRINGr#updaterNEWLINEr%stripCOMMENTr r/_find_statementsr PYBEHAVIORmodule_firstline_1min)r)indentZexclude_indentZ excludingZexcluding_decoratorsZ prev_toktype first_lineemptyZ first_on_lineZtokgenZtoktypeZttextZslineno_Zelinenor<Zshould_excludelr+r+r, _raw_parseust                zPythonParser._raw_parsecCs0|dkr|j| |  }n|j||}|S)z?Return the first line number of the statement including `line`.r)r%rF)r)liner+r+r,rTszPythonParser.first_linecsfdd|DS)zMap the line numbers in `lines` to the correct first line of the statement. Returns a set of the first lines. csh|]}|qSr+)rT).0rW)r)r+r, sz+PythonParser.first_lines..r+)r)rr+)r)r, first_linesszPythonParser.first_linescCs ||S)z)Implement `FileReporter.translate_lines`.)r\)r)rr+r+r,translate_linesszPythonParser.translate_linescsfdd|DS)z(Implement `FileReporter.translate_arcs`.cs$g|]\}}||fqSr+)rT)rZab)r)r+r, sz/PythonParser.translate_arcs..r+)r)arcsr+)r)r,translate_arcsszPythonParser.translate_arcsc Csy |Wnbtjtfk rn}z>t|dr6|j}n|jdd}td|j|jd|fWdd}~XYnX| |j |_ |j |j B}|j |}| |||_dS)zParse source text to find executable lines, excluded lines, etc. Sets the .excluded and .statements attributes, normalized to the first line of multi-line statements. linenor1rz5Couldn't parse '%s' as Python source: '%s' at line %dN)rXrD TokenErrorIndentationErrorhasattrrcargsrrr\r!rr#r r)r)r*rcignorestartsr+r+r, parse_sources  (  zPythonParser.parse_sourcecCs|jdkr||jS)zGet 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,ra s zPythonParser.arcscCsnt|j|j|j}|t|_x>|jD]4\}}||}||}||kr*|j ||fq*W|j |_ dS)zkRun the AstArcAnalyzer and save its results. `_all_arcs` is the set of arcs in the code. N) AstArcAnalyzerrr r%analyzerr'rarTr9missing_arc_fragmentsr()r)Zaaal1l2Zfl1Zfl2r+r+r,rks  zPythonParser._analyze_astcCs~tt}xF|D]:\}}|dkr&q||jkr2q||jkr>q||d7<qWx&|jD]}||krZ||d8<qZW|S)zYGet a count of exits from that each line. Excluded lines are excluded. rr1) collections defaultdictintrarr")r) exit_countsrorprWr+r+r,rt&s    zPythonParser.exit_countsc Cs|jdkr||}|rP|dkrP|| krP||f|krP||f|jkrP||}}|j||fdg}g}x|D]\}}|dkr|dkr| |f|jkr|| |Sd}nd}|j|d}dj||d} |dk r| d j|j|dd 7} || qnWd |S) z5Provide an English sentence describing a missing arc.Nr)NNz didn't jump to the function exitzdidn't jump to line {lineno})rczline {start} {emsg})r2emsgz, because {smsg})smsgz or )r(rkrFmissing_arc_descriptionformatappendjoin) r)r2endZ executed_arcsZ actual_startZfragment_pairsZmsgsrvrumsgr+r+r,rwAs.    z$PythonParser.missing_arc_description)NNN)N)__name__ __module__ __qualname____doc__rr-propertyr/r=rXrTr\r]rbrjrarkrtrwr+r+r+r,rs = a  rc@s<eZdZdZeddd ddZddZd d Zd d ZdS)r.z3Parse bytecode to understand the structure of code.unicode)rNc Cs||_|r||_nLyt||d|_Wn8tk r\}ztd||j|jfWdd}~XYnXx dD]}t|j|sdtdqdWdS)Nexecz5Couldn't parse '%s' as Python source: '%s' at line %d) co_lnotabco_firstlinenozsThis implementation of Python doesn't support code analysis. Run coverage.py under another Python for this command.) rcoder SyntaxErrorrr|rcrfr)r)rrrZsynerrattrr+r+r,r-ls$  zByteParser.__init__csfddtjDS)z~Iterate over all the code objects nested within this one. The iteration includes `self` as its first value. c3s|]}tj|dVqdS))rN)r.r)rZc)r)r+r, sz+ByteParser.child_parsers..)rr)r)r+)r)r, child_parsersszByteParser.child_parsersc cst|jdr6x|jD]\}}}|dk r|VqWnt|jjddd}t|jjddd}d}|jj}d}xTt||D]F\}} |r||kr|V|}||7}tjj r| dkr| d8} || 7}q~W||kr|VdS)zYield the line numbers possible in this code object. Uses co_lnotab described in Python/compile.c to find the line numbers. Produces a sequence: l0, l1, ... co_linesNrr1) rfrrrrrziprrPZnegative_lnotab) r)rVrYbyte_incrementsline_incrementsZ last_line_numline_numZbyte_num byte_incr line_incrr+r+r, _line_numberss(   zByteParser._line_numbersccs.x(|D]}x|D] }|VqWq WdS)zFind the statements in `self.code`. Produce a sequence of line numbers that start statements. Recurses into all code objects reachable from `self.code`. N)rr)r)ZbprWr+r+r,rOszByteParser._find_statements)NN) r}r~rrrr-rrrOr+r+r+r,r.is  r.c@s"eZdZdZeedddZdS) LoopBlockz@A block on the block stack representing a `for` or `while` loop.)r2cCs||_t|_dS)N)r2r break_exits)r)r2r+r+r,r-szLoopBlock.__init__N)r}r~rrrrsr-r+r+r+r,rsrc@s$eZdZdZeeedddZdS) FunctionBlockz>A block on the block stack representing a function definition.)r2namecCs||_||_dS)N)r2r)r)r2rr+r+r,r-szFunctionBlock.__init__N)r}r~rrrrsstrr-r+r+r+r,rsrc@s$eZdZdZedddddZdS)TryBlockz6A block on the block stack representing a `try` block.zint|None) handler_start final_startcCs0||_||_t|_t|_t|_t|_dS)N)rrr break_from continue_from return_from raise_from)r)rrr+r+r,r-s zTryBlock.__init__N)r}r~rrrr-r+r+r+r,rsrcs"eZdZdZdfdd ZZS)ArcStartaThe information needed to start an arc. `lineno` is the line number the arc starts from. `cause` is an English text fragment used as the `startmsg` for AstArcAnalyzer.missing_arc_fragments. It will be used to describe why an arc wasn't executed, so should fit well into a sentence of the form, "Line 17 didn't run because {cause}." The fragment can include "{lineno}" to have `lineno` interpolated into it. Ncstt||||S)N)superr__new__)clsrccause) __class__r+r,rszArcStart.__new__)N)r}r~rrr __classcell__r+r+)rr,rs rZArcz lineno, cause ArcStartscCstdd|DS)Ncss|]}t|tVqdS)N) isinstancer)rZxr+r+r,rsz..)all)seqr+r+r,rZCOVERAGE_AST_DUMPc@seZdZdZddZdS)NodeListzA synthetic fictitious node, containing a sequence of nodes. This is used when collapsing optimized if-statements, to represent the unconditional execution of one of the clauses. cCs||_|dj|_dS)Nr)bodyrc)r)rr+r+r,r-szNodeList.__init__N)r}r~rrr-r+r+r+r,rsrc @seZdZdZededddZddZeeeddjd d Z d d Z eedddZ ddZ ddZ e ZddZe Ze ZddZddZdddddd d!d"d#d$d%d&h Zed'dd(d)Zed*ed'ddkd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zd5d6Zed'd7d8d9Zed'd7d:d;Zed'd7dd?Z ed'dd@dAZ!ed'ddBdCZ"e"Z#ed'ddDdEZ$ed'ddFdGZ%e%Z&e"Z'e"Z(ed'ddHdIZ)ed'ddJdKZ*ed'ddLdMZ+ed'ddNdOZ,ed'ddPdQZ-ed'd'd'dRdSdTZ.ed'ddUdVZ/ed'ddWdXZ0ed'ddYdZZ1ed'dd[d\Z2e2Z3d]d^Z4d_d`Z5e5Z6dadbZ7dcddZ8e8deZ9e8dfZ:e8dgZ;e8dhZre8diZ?d S)lrlz>Analyze source text with an AST to find executable code paths.r)rrcstt||_fdd|D|_|_trXtd|jtd|jt |jt |_ t t|_g|_tttjdd|_dS)Ncsh|]}||qSr+)rF)rZrW) multiliner+r,r[sz*AstArcAnalyzer.__init__..zStatements: {}zMultiline map: {}ZCOVERAGE_TRACK_ARCSr)astparser root_noderrAST_DUMPrCrxast_dumprrarqrrlistrn block_stackboolrsosenvironrFdebug)r)rrrr+)rr,r- s  zAstArcAnalyzer.__init__cCsBxszAstArcAnalyzer.nearest_blocks)returnscCs2|jj}t|d|d}|dk r(||S|jSdS)z}What is the right line number to use for this node? This dispatches to _line__Node functions where needed. Z_line__N)rr}rrc)r)rrhandlerr+r+r, line_for_nodeBs zAstArcAnalyzer.line_for_nodecCs$|j}tjjr |jr |jdj}|S)zSCompute first line number for things that can be decorated (classes and functions).r)rcrrPtrace_decorated_defdecorator_list)r)rrcr+r+r,_line_decoratedPs  zAstArcAnalyzer._line_decoratedcCs ||jS)N)rvalue)r)rr+r+r, _line__AssignXszAstArcAnalyzer._line__AssigncCsBtjdkr8|jr8|jddk r*|jdjS|jdjSn|jSdS)N)r)rZ PYVERSIONkeysrcvalues)r)rr+r+r, _line__Dict]s  zAstArcAnalyzer._line__DictcCs |jr||jdS|jSdS)Nr)Zeltsrrc)r)rr+r+r, _line__ListlszAstArcAnalyzer._line__ListcCs*tjjr dS|jr"||jdSdSdS)Nr1r)rrPrQrr)r)rr+r+r, _line__Modulers zAstArcAnalyzer._line__ModuleZAssignZAssertZ AugAssignZDeleteZExecZExprZGlobalZImportZ ImportFromZNonlocalZPassZPrintrcCs<|jj}t|d|d}|dk r(||St||hSdS)aAdd the arcs for `node`. Return a set of ArcStarts, exits from this node to the next. Because a node represents an entire sub-tree (including its children), the exits from a node can be arbitrarily complex:: if something(1): if other(2): doit(3) else: doit(5) There are two exits from line 1: they start at line 3 and line 5. Z _handle__N)rr}rrr)r)rrrr+r+r,add_arcss  zAstArcAnalyzer.add_arcszfrom_start, prev_startscCs|dkr|h}xv|D]n}||}|j||}||jkrX||}|dkrNq||}x|D]}||j||jq^W||}qW|S)auAdd 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) rrrFrfind_non_missing_noderrcrr)r)r from_start prev_startsZ body_nodercrTZ prev_startr+r+r, add_body_arcss       zAstArcAnalyzer.add_body_arcscCsP||}|j||}||jkr&|St|d|jjd}|rH||}nd}|S)aSearch `node` looking for a child that has not been optimized away. This might return the node you started with, or it will work recursively to find a child node in self.statements. Returns a node, or None if none of the node remains. Z _missing__N)rrrFrrrr})r)rrcrTZ missing_fnr+r+r,rs   z$AstArcAnalyzer.find_non_missing_nodecCs2|t|j}|r|S|jr.|t|jSdS)N)rrrorelse)r)rZ non_missingr+r+r, _missing__Ifs zAstArcAnalyzer._missing__IfcCsTg}x*|jD] }||}|dk r ||q W|s8dSt|dkrL|dSt|S)Nr1r)rrrylenr)r)rZnon_missing_childrenchildr+r+r,_missing__NodeLists   z!AstArcAnalyzer._missing__NodeListcCsV|t|j}|sdSt}|j|_t|_|j|j_d|j_|j|_d|_ |S)NTrue) rrrrZWhilercNametestidr)r)rZ body_nodesZ new_whiler+r+r,_missing__Whiles  zAstArcAnalyzer._missing__WhilecCs.|jj}|dkrdS|dkr*|jdkr*dSdS)z Is this a compile-time constant?)ZConstant NameConstantNumrr)rFalseNone __debug__N)rr}r)r)rrr+r+r,is_constant_exprs zAstArcAnalyzer.is_constant_expr)exitscCsRxL|D]@}t|tr(|j|Pq t|tr |jdk r |j|Pq WdS)z0Add arcs due to jumps from `exits` being breaks.N)rrrrrKrrr)r)rblockr+r+r,process_break_exitss   z"AstArcAnalyzer.process_break_exitscCshxb|D]V}t|tr>x |D]}||j|j|jqWPq t|tr |jdk r |j |Pq WdS)z3Add arcs due to jumps from `exits` being continues.N) rrrrrcr2rrrrrK)r)rrxitr+r+r,process_continue_exits*s   z%AstArcAnalyzer.process_continue_exitsc Csx|D]}t|trb|jdk rHx |D]}||j|j|jq(WPq|jdk r|j |Pq t|t r x,|D]$}||j|j |jd |j qrWPq WdS)z0Add arcs due to jumps from `exits` being raises.Nz didn't except from function {!r})rrrrrrcrrrrKrr2rxr)r)rrrr+r+r,process_raise_exits6s       z"AstArcAnalyzer.process_raise_exitsc Cstxn|D]b}t|tr2|jdk r2|j|Pq t|tr x,|D]$}||j|j |j d |j qBWPq WdS)z1Add arcs due to jumps from `exits` being returns.Nz didn't return from function {!r}) rrrrrrKrrrcr2rrxr)r)rrrr+r+r,process_return_exitsJs   z#AstArcAnalyzer.process_return_exitscCs(||}t|dd}||gtS)Nz*the break on line {lineno} wasn't executed)r)rrrr)r)rhereZ break_startr+r+r,_handle__Breakbs   zAstArcAnalyzer._handle__BreakcCs|j}}|jrtjjrd}x8|jD].}||}|dk rN||krN||||}q$Wtjjrn||||}|jr||jd}|j ||}x0t |d|D]}||j kr||||}qWt |hS)zBAdd arcs for things that can be decorated (classes and functions).Nrr1) rcrrrPrrrrrrFrrr)r)rZ main_linelastZdec_nodeZ dec_startZ body_startrcr+r+r,_handle_decoratedis(       z AstArcAnalyzer._handle_decoratedcCs(||}t|dd}||gtS)Nz-the continue on line {lineno} wasn't executed)r)rrrr)r)rrZcontinue_startr+r+r,_handle__Continues   z AstArcAnalyzer._handle__ContinuecCs||j}|jt|dt|dd}|j|j|d}x|D]}||j ||j q@W|j }|j }t|dd}|j r|j|j |d}||O}n |||S)N)r2z'the loop on line {lineno} never started)r)rz)the loop on line {lineno} didn't complete)riterrryrrrrrrcrpoprrr9)r)rr2rrrmy_block else_exitsr+r+r, _handle__Fors       zAstArcAnalyzer._handle__ForcCsL||j}t|dd}|j|j|d}t|dd}||j|j|dO}|S)Nz-the condition on line {lineno} was never true)r)rz.the condition on line {lineno} was never false)rrrrrr)r)rr2rrr+r+r, _handle__Ifs    zAstArcAnalyzer._handle__IfcCs"||}|j|jt|d}|S)N)r)rrrr)r)rr2rr+r+r,_handle__NodeLists z AstArcAnalyzer._handle__NodeListcCs(||}t|dd}||gtS)Nz*the raise on line {lineno} wasn't executed)r)rrrr)r)rrZ raise_startr+r+r,_handle__Raises   zAstArcAnalyzer._handle__RaisecCs(||}t|dd}||gtS)Nz+the return on line {lineno} wasn't executed)r)rrrr)r)rrZ return_startr+r+r,_handle__Returns   zAstArcAnalyzer._handle__ReturncCs|jr||jd}nd}|jr4||jd}nd}t||}|j|||}|j|jt|d}|jrd|_ |jrt |_ n |j t }|jrd}xT|jD]J} || }|dk r| |||}d} t|| d} ||j| j| dO}qW|jr|j|j|d}||O}|jr|j ||jB|jB|j B|jB} |j|j| d} |jrtjjrxD|jD]:}|j}|jj|d}x| D]}| |j||qWqpW|j}n||j| }|||jrFtjjr.xD|jD]:}|j}|jj|d}x| D]}| |j||qWqW|j}n||j| }|||j rb|||j | |jrtjjrxD|jD]:}|j}|jj|d}x| D]}| |j||qWq|W|j}n||j| }|||r| }|S)Nr)rz3the exception caught by line {lineno} didn't happen)r)r)rc)handlersr finalbodyrrryrrrrrrrrrrrrrrPZfinally_jumps_backrcrrx_combine_finally_startsrrrr)r)rrrZ try_blockr2rZ handler_exitsZlast_handler_startZ handler_nodeZ from_causerZ final_fromZ final_exitsZ break_linercrZ final_exitZbreaksZ continue_lineZ continuesZ return_linerr+r+r, _handle__Trys                      zAstArcAnalyzer._handle__Try)rirrcsVg}x0t|D]$}|jdk r||jj|jdqWd|fdd|D}|S)aHelper for building the cause of `finally` branches. "finally" clauses might not execute their exits, and the causes could be due to a failure to execute any of the exits in the try block. So we use the causes from `starts` as the causes for `exits`. N)rcz or csh|]}t|jqSr+)rrc)rZr)rr+r,r[Asz9AstArcAnalyzer._combine_finally_starts..)sortedrryrxrcrz)r)rircausesr2r+)rr,r4s  z&AstArcAnalyzer._combine_finally_startscCsg|_||S)N)rr)r)rr+r+r,_handle__TryExceptDsz!AstArcAnalyzer._handle__TryExceptcCsbg|_g|_|jd}|jjdkrX|j|jkrXt|jdks@t|j|_|j|_|j|_||S)NrZ TryExceptr1) rrrrr}rcrrr)r)rfirstr+r+r,_handle__TryFinallyLs z"AstArcAnalyzer._handle__TryFinallyc Cs||j}}||j}d}|r6tjs2|dkr6d}tjjrBd}|rV||jd}|j t |dt |dd}|j |j|d}x|D]}| |j||jqWt}|j} || jt |d d}|jr|j |j|d} || O}n|s|||S) NFrTr)r2z-the condition on line {lineno} was never true)r)rz.the condition on line {lineno} was never false)rrrrPY3rPZkeep_constant_testrrryrrrrrcrrrrKrrr9) r)rr2Zto_topZ constant_testZ top_is_body0rrrrrr+r+r,_handle__While]s0        zAstArcAnalyzer._handle__WhilecCs"||}|j|jt|d}|S)N)r)rrrr)r)rr2rr+r+r, _handle__Withzs zAstArcAnalyzer._handle__WithcCsl||}|jrL|j|jt| d}x@|D]}||j| |jdq,Wn|| |||| dS)N)rzdidn't exit the module)rrrrrrcr)r)rr2rrr+r+r,_code_object__Modules  z#AstArcAnalyzer._code_object__ModulecCsN||}|jt||jd|j|jt| d}|||j dS)N)r2r)r) rrryrrrrrrr)r)rr2rr+r+r,_code_object__FunctionDefs   z(AstArcAnalyzer._code_object__FunctionDefc Cs\||}|| ||j|jt|d}x*|D]"}||j| |jd|jq2WdS)N)rz"didn't exit the body of class {!r}) rrrrrrcrrxr)r)rr2rrr+r+r,_code_object__ClassDefs   z%AstArcAnalyzer._code_object__ClassDefcsfdd}|S)zFA function to make methods for online callable _code_object__ methods.c sB||}|| |dd|||| dd|dS)Nzdidn't run the {} on line {}zdidn't finish the {} on line {})rrrx)r)rr2)nounr+r,_code_object__oneline_callables  zPAstArcAnalyzer._make_oneline_code_method.._code_object__oneline_callabler+)rrr+)rr,_make_oneline_code_methods z(AstArcAnalyzer._make_oneline_code_methodlambdazgenerator expressionzdictionary comprehensionzset comprehensionzlist comprehension)NN)NN)@r}r~rrrrr-rmrsrrrrrZ_line__ClassDefrZ_line__FunctionDefZ_line__AsyncFunctionDefrrZ OK_TO_DEFAULTrr rrrrrrrrrrrrZ_handle__ClassDefrrZ_handle__AsyncForZ_handle__FunctionDefZ_handle__AsyncFunctionDefrrrrrrrr r r Z_handle__AsyncWithr rZ_code_object__AsyncFunctionDefrrZ_code_object__LambdaZ_code_object__GeneratorExpZ_code_object__DictCompZ_code_object__SetComprr Z_code_object__ListCompr+r+r+r,rl sx         m   rlctxcCs$|dgditgkp"t|tttfS)z:Is `value` simple enough to be displayed on a single line?Nr+)rrrrsfloat)rr+r+r,_is_simple_valuesrc Csd|}t|tjs.td||jj|dSt|dd}|dk rPd|j}nd}d||jj|}dd t |D}|std |nt |d krt |d d r|d \}}td |||nt||d} x|D]\}}d| |} t |rtd| |qt|t rXtd| x|D]} t | |dq0Wtd| qt| t ||dqWtd |dS)zhDump the AST for `node`. This recursively walks the AST, printing a readable version.  z {}<{} {!r}>Nrcz @ {}z{}<{}{}cSs g|]\}}|tkr||fqSr+)SKIP_DUMP_FIELDS)rZrrr+r+r,r`szast_dump..z{}>r1rz {} {}: {!r}>z z{}{}:z{} {!r}z{} [z{}])rrASTrCrxrr}rrc iter_fieldsrrrr) rdepthrSrcZlinemarkheadZ named_fields field_namerZ next_indentprefixnr+r+r,rs<       r)r)0rrrqrr5rArDZcoveragerZcoverage.backwardrrrZcoverage.bytecoderZcoverage.debugrZ coverage.miscrr r r r r rrZcoverage.phystokensrrrobjectrr.rrr namedtuplerrrsrrFrrrlrrrr+r+r+r,sF    TR  /