ÿØÿà JFIF    ÿÛ „ !.%+&8&+/1555$;@;4?.451 4,$,44444444444414444444444444444444444444444444444444ÿÀ  á á" ÿÄ     ÿÄ ?    !1AQaq"2‘¡±ÁðBRbrÑá#‚’¢²3S CñÿÄ   ÿÄ !    !1QAa‘2ÿÚ   ? 5˜Z¯V¦cø)›t/? z¨±>Õ5€¶‹Á¤·¼z¼Ü¬+ñ®v¤¨_ˆR­BFn©—˜ý®ç̝P8gýt·ÉSTŦˆìät?þé¼íìN/Þa)ì–í6ô… Ï¿øÃj´¿KÇü]ÿ ªô¹-eKànëÕHTx}ýSÜ›ÿ ”7Ø×&µ<¦  ¥ÑO¶[Ù¯ä¨ÞÃÿ PZ-¬;#õ|•oaÿ ©CìÞz3˜öː/¤­ñTûIØ}š^ mÓ%ªxˆ¥ÉŸu=Z+ISe¿45™¼u;ú&WØ÷€æßQ™®{|íx*TC“#ZŠìZ§²‹ 6pv…³¿¡äª*áZÐ%ÒOáˆo"x«OHk w±æ+¬V(kMúŸ5Vö«$ ÁrÏbàb57/luR ¸ÑÛj Òµì`Ðœq­û žICÀÊ•©4€Âcà¨Ï€O´<èÐ:›ù(Ë^L8þ‘ÍÌ#¸Ð_Ì©ÙK(Öz 4¬û+¸;ü’V’84‘¬ÃŽ:[â‡ÔÌáõp¢~§ªlæ£ö{®G>J¼"°‡7¯ÆÉèßû ‹É‹§ÁòÃýâßî ^ƾÙõ‹×óH#«LP½ïX=xÑÍ$|W?•~• îëÔ©ª‹ {ÝT…Kÿ ”hûâá)J*ö˜–ÔU;iÇ€/ ÆþjóZ\ýwØ=Ìm ºèËL9 ýèÆð/¨’¥öo=nË.%Îì ŽÕ¯È|{Oj²ƒE6e/ßdÄõ²Ìâ1O®ò×TsəԸhOMýíMˆ¿¼H˜l²,7Â¥#MF/Úf°Ö½± ¸–dr‹NýÊ íjqx{œÉ ä-È ¦ øÄër¨q°ð †nцýÑÄÆ’mä…n<0È™;ÁÝá¯ÁZƒ7FÀmì­ É&9ˆîéi¶ùN§Y• ÃZãAâ?•‡©‰ , ó¾IŸŠc1 4â&y­&pŠ­6;M À 0¹qç»p.á …ŸÅáK@%6·y6ƒ‰3?”úºŽ‰éX5ªPT §µ!=Mž«Ú½‹ÅgÂSâÉaþÓoö–¯ÁÔìR>5éÿ üs¶ÆUcÌ kÇR ]ÿ ù¬¼«VŽ;Â|‡~¢¦”ÏÅ°æ {L™Õ°Óv¹ò¸írŽ¡×¢CÃ!íVÕ {¶»sŒNPg/ "uÕbkm²“$ďå¿é¹§°½æz¯6 †s¿!s–wÚÝ“™Œ °.ûj>·+™Òa…©Œ&rÝÎtÛë긪Ît’LAVp%c Úý[ÄzJ¾ÇàXXç@˜ó<êL]·T˜¾¥1Ó©V‡g´æ½¦Ý@¹óø!_@´ÞâSÁ —S3™•& ]@JHÚý©ZŽ €×æÔr»Áf!‡yÞ4Mv*èÓã_{‘åóUuљØ«Oïé*®EvÑ Œ÷‡U \"㪒ÍK+À 4“M¡ï:0¥5í!'<@î´”>Ç»&Z–ïCCV˜Ì5Šo&îhè.žû |ÓK©h$s6KìŒëã)¹hI¦GïOåóI;ììü#É$Š0…Ææ¥TØ.5­¾gn´ “ÂÖ\:hœ89G)J@„}œ:’Ò{/Š"¦_Æ×7Æ3VÇŠÊa]ÚŒÙ€Ä–=®uÁßâACZƒ§§£ Qnâ:«,×{tyø¬iÛcœÜÄ€H½ÄÍCk´÷šß .W'b¤Íåh]÷€=,Žv×cÚEÚHXJX¶îo¨FÒtèöŸ>ªª6[J®Fµ£sGÁeqõfe\íjÒÐïÄÐGˆe1Ø‹.Ø”‘Ëuø Y­ˆÜ ŽG|zùªüMpDnQWÄ”%JŠ™)â*p@Örš«ÕT2Ð%ˆG#ª„ ·¤!°ŸOTÂT¸aÚ%4&h™LµšØüÐ.F¿²ÐÞ_Ç‚¾ÅÃaÜ÷09Æ q€öy˜v‡85õN÷]¬äѼóS{°_MŽ¬úÔ#°Ç¸0åÞè2ëôPcvÆw9®ií1Ä8F™˜à‰´+‰Ik1òÝ7“Ñ×ÒsÝ\x‚h`ÞÑ`ó"|µEcý£n˜h`}GÞ !±ù²Ápü²ß6 0ïi󜵩SÈÇ7˜-ÕURO˜¦´f$ªž-Í6(œ}<„ éc øs]ŽŽ„*—¾ ìdŽ„)méª\¿êÎIg¾ØÞ~I#C/¼¼´EÁÈŽi8“©õådô·>euä ƒ'Ê×लR1ÉJE1ÐAát`t;ÇР%Ý<‡¥„ÍÆ`×Oyó)õiI€ñQaŸ4Ûù\áàaÃÔ¹HÃu¹*k€¦<„e S‡&õÏ B!ŽhüÞ`yj}mªf×\¿ Ç~æ­9‡û\՞Ǖg²1Žû5V7 !àöšm° c`ܬøÇìµÒ'P"?…´Ö,"§^•õŽ¨sÔ)6˜sæéÍR¼ ò|Sl”‹7 nPW Gòú÷½§O¯‡„l¡kSÞŒr½PÊ@æ¢pŽ-mÿ #Ÿ˜Àº¶Áä¦;ïÔæ$1££`“Õ>„—·ž)ßð³ñ#Ï Ô$¶œ‰ÊE‹À;÷º ¯«P:Ñ”8–IÊtpÞ3ª“>ê“þës4ò2OÏÕ­±zô†Õ§‰.÷ä¸;¿˜“'œ›žª}«Œ{ª±Ì 9ÔóÞÕ‡0 $íWV3Üì¬ —@kÝ4@¿r¼±½¬™›?øØæ´'Áé®CË3-g$˜ö‡×auÚi´Žp/êÛ æF›Ú2v‹ã¿¿,nB1̨ƃqÞa5͝@&Æû“él÷ \C²½UÍc ¯k×¢U ÖéQå™—-r wô ÞÏ<Ò=&=ÿ Ôê Òêˈt,i—;LîÜ á¸*ÚÃ1$êL•LÍ <É)ýÐà’ ;F™{ƒ™˜€&'}‚ãÄK`¡ÞT@I;®žZóè‚s’7®°›+§O­Åq©é»²9<Ô J ¼9O’HL»Ùïì¸rk¼Ž_ý‘TŸu[²ßÚŒ·ü÷B%¯E ŸÔX5êO´ Ç•€’I0 ÉJX` ñ¹õ%;µŸD‘«´€àwÒ™U ûئžÖö\×®×´8 ½‡ºÐÆÓ§?Àkmœ=;d5*@-ì0F Rªýš[Ü6âö̃ڸr*KA9· u*µæ£?U¸Âêí†8@¦X4 e-ò„0s{ HâUpU?¼mñRa°®a%Ð'tÉ×’\¾ÊÉ]t›h>·(Ë@R¼¡Ãt h}’O÷au<+nT…Ö…MӐ??Óe95 q>í/;&JSû °¯ÊéÞ øƒ*Ã2½Ài&:nôUl=¾¿5eˆ3”ñc|Ú2V”>„»&eE;«ÚäC p¢Û úy 9š[ŒÌx¼擼A&DåÒ¯ˆ¤ÀÌ;"˜ ÏQä¸åhÊ}Ûq«Û0WžÒ|»€ø®öCm5•\ÇÀ§Pe3£]0ÃàLDÉ‰1øªxjgwT‚÷¿LΨK‹›ùs—xˆÜ±µ kæ¸f‰‰ÜGk/LÛØ6d9ò¶ùA{ƒA3š/¬D¬khÓk‰`˜"㯒r¿±Óã jx‡°e}<Ñø\3y:'À•/h½Í€Ç4~g ?Û(¼]v‘ªlKÎâ~?O‚W%{Ì:“'©úNq¾›úo(X’¥¯ˆ nFê{Ç€ü?º'ë ø‹ì Þ09ŒÌç9Æ —ËC`j@ÓÄ(+a‹un¸#ÂꟋ{K`‘ÑÍÍ'à´»/Û,KW;Þ4²þð ï Nm|~fGÏ(…³Ã)«1ö­Õ ¥‡¨©ƒÃ™ü-s=à=U66Ï«Ýc蓦W¹íž®›nÔ%êÇìŒ<#Ü×84ån®Ð ÒåOC` ñânÑs‡¢ç 1õ%Îhì½Ã½® e:ݼUZo™`  ÅZŸŒÊ«ê1ÏÄo$q¹Þ€©ˆhÐÉä¯ñ[!…Ú˜àJ:x2$Íß&PåT£6ç— ‡Í*4Ýšçjÿ ‰É nófÐ ó(L5C•åÆ\rMÒ@ò }y-W}™üýVù—ú¢=Ù”c®‘< M ž ´Phr ¦©TD ‘ù.$´÷O‡‘V2Æò.=IUŒ=ž‡â¬i™aþÓåÙ?òUø'ØÖ•.~* šTŒ!•-×áºTâ®ä#õü'´ eýlYÅÓeÕKÂrT"CÚ@u!Óxƒ{š3€}1¿(r}%«nËamjÑ%ÑNEò v ˜à  σöK³,*º.àzù¨™Ó ÚçâU¦*¿ 9{%Ö¹ njûdaXöb) kÛƱûÓ\°M7ˆÂ=û›ç¿Ã‚­V»Cg–8ÙêE- j)k$º`Ã-ùEýeBÆÇ]c¡°ñty&Òd0nõ'¡W+ƒ*|–øµFa\GQªEAÔp5\Ǽ·¼Ç8·õ -â§Ú[ ‡ uZeÖ 3}×d'+¹:ð+K†Û®s!Ï$úe€<Û”x)1»a­¡LC]¸µík…ÚàA»AYº{†ªS[¦5HÒ7ù --,ísòDØ€èk ÞÀîÜ ò@â( ËNˆë›4ô½•/¦o‡€Û7 ê•ÆêòðÜy'Án½µ á˜ݦ ndeo…[ì¶Ê,¥R³Ä=À±—–ß;£™´ñSâ*g§”ïaið‘Jå~™ÓÞ ß³Õ¢»8x埒²52>AÊb&-÷\7´éÄù€T˜,w;3{ï˜k…à¹ÄqÀ«œ{€\ ˆ¾[´¨јr &Úé„Ívˆ±8†¿]|¬ņ4I×pÞS1ÈÖz‰#Ìv‡G!YNògñ:màTz¢Ý1ô©^O=~ë|5Bã™ç•¼µõ•bÆ@úÕS¬ÈŒ#¬zünrŸ û” Z²•ï›èðV"ÁHÚý©wÝ €7¼Ìu1hÑa3Éä û f$o¿É ™Ú›ÝçnpÒ3äÌ3†Í§,Äï]$‰/pê †«À¼¸e9­Æê_C]žƒ·ý·frÁN«, E=›Çq -‰öŒ:aÏ¿±í&£Í:-} 84‘ÿ eƒQÑeëSsuiA ³g㟥ú£?ÿ ʼn*”“÷aühe:ÊWa@ÒÞk±eØ] F Ô—r.åä˜ @ö¥ªZoÐýYL·¥S²G/‡ñ <~*ZÆ´è>JlòàÛƽÿ 窘ìGN¢:I®KšJp/`íIÁÀõ#Ä-€ö­šµŒoF4|ÆQØÆ@Ì|£Ô…¢À{9˜è½Üó›€ôYÒÎYsið;ís¤€à²ˆ‚4qÉVŒI$ ‰"° æµ8cXGjœˏ¡Aâý•ËÜ¢ûï e·çLx']á"oÅÎê3¯Ç—¹”ó0nå‚âg{Œñ> S´˜îè°g238‚ãköÝfÚd´6Ò€;ò÷±¢™¼›º ¢Æ'¥Ðx'e¬ç ]bÈÆV¢ó‹kýBO ðÊâ$Ÿ!×T 3Mýמ žìٍàÌü‘8÷€àæØ8æ©6‰©L´«…oãpð„~Çk‰!ñ;‹”ÛžÍ àž±z Ÿôû øŸÝužÏ;ÿ #|u6™Þ¬ÚˆÐõA4¶â|ôl|Ê2ŽÇ¤ÝÅÇY.<#Aí.k§hóF‚”Y; M½Ö4hŸ4&›­¿tès´%FìL¥£Ãk‰ÇT¤haÁ¤ÚxfÉ`ÑìË›>i 3t‚:,–+^÷´–{Û–Nxi"x‘Ûg î¨>¥Õ܁ùZH,2Û“:8xÊ¢Çí9.É-Ìâã-=çjwµS˜dütžçwýGòú®®ûº_ˆýx$–¡ãøO EÚÛÏ÷R„×w+3£Á£öUMyR²¹âŒ°š›¸Ñãò9§Ó_Dl+Ùßc›úšGÅÌc†Ž!Ko=¶.‘Îÿ c²(2®V mª.ÿ ¹B›¹å ù„öŸSV>™ü¯$y:G¢Z×àøúdî¹û­·ýÇ´:•c LÍõi_‹ö+ÎæGÊè>OŠ•äž´§Þ{X}¨1ÚTc›»Qþ•êô°t¿OP?eæ~É{5]•ÙR£r5†nZ\ã@ &îJõ ¾àC°þV>fé¥/ü5ñÊIº_é5 ;e­h<@ Ä&æÃëE%;X,ÒãÆÞ`Oò¦kŸm#˜!ÀyÄ¢| óLšò¥Ä` ¶R=|ÈCâh5ò3DˆïF†ðÒ#ÅìÛœ?¸yhBãœí ZxßÎÄhºRK„`Þödvײ™ÀÈÑÒgŒuY w³%†ƒÓzõ ÖÏp‚dH®¦A´ù§»ÓÇMæ~)ˆð‡û:ù&Ä •vGD´À n ݇¼Ö8Fö óáà£~Ë¥x`oK|Ä?fxiØü%pìR>éò+Û±éÎ>núlFŤ'tq8LZÏvÃ?„¡ß±È⽆¯³íü@x|PöUäèØã¡ð‚ŒAìÏ"vÍwóŸÍ{ ý0.z È•Ö{,N¡£¡ŸKÕÙž>Ýœþ ÍÀ°<×EA!Å‚D™IúOÍ¡>ôG}Â` ÍßkÜL™Ž Þð™ {IøF²¹òQ3&!ÃÂÞz.d&Ï-sH¸,Ôõ˜ŽP€ 77ˆÝ¼ÊëÜw =cÕ Ú,ØÐ5ÎYÐ)ì´öœgŒ[¤ßv㙑8心>h]§µháYš£²ºÑ.{Ï7Sð•?´~×SÃKýJÛ˜ ™Íäiúu<µX¶1õ^kâçIÑ£sZ4h>j*ÔšD:4­¿_ ÷¸ Õxæÿ ¸?Mù _•­ÊÐ ä ÷ý ÑwL œ­ïnTkÛUÍN©ë:¦fV ¶ÜÔÜMªÅâA½–¿R×TXš-%iTÊT•‡Ù‚JôϐZxWÑè‰f‰òG º ×Õû2aZ7OU3[“×AT–ÞŒ…-‘¤”Ì ì&(ˆ¿­•ƒkï’:ðY¦W‘ Å)“†‘˜³Åtcø˜ñTÂwÚÇ4|üLÇªí–v- qˆèU qPE.†â‘˜µ Æ,ÐÅs]8¾„oúÑ i>ÜxxÈó)ƒ ´æÁâØ$À‰vžŸf$Ž |ãw;ÀÁIJ»b` {¦Ó¤Ú$©YÀ‘n@Óïž«9J¼êG m¤ ܯ¹ÌW4€ÐÒÅÛ‡#褕Ÿn-?í|с¥÷Ú¹¬'´ÞÜ9ÓK `hê£SÄSà?7—Wí_´…óB›»:=Ãïq`<8ñÓŒÑlú2d¬ê³£hÖ[l|$vÝro~'R®‰§°ñmY ͧäP |PUª¹·:3Œ[Û{Xÿ ºâ@‚W–Äé u‚ ¯´*=íή.pûÒdt @G‰¬ s¸ ëÉücr ÞæѨÊ@>¤¢Ö±. Þ'¯°ÌME[YéïĵÂCå½ Ué©Áû'Ê9%eÔðNU”ë‘ÌsD3/®+UI˜9h.WC”빓$#:pz:YÓ ¿xž* ³$Í +$kñAŠ‹†¢ Uê>¸)_š¬÷©ßAÂÔb9ÇU ¯¾á•9¯ÏÏ÷O÷¼¼Fähal1‰3Ì[Ïr•´UCksNÐ] R‘¸¥H+§Šé†c©vÖÞ0iÓ76s†î!§=ß ¼~Ô'°Ãmäoäš³ªøi1úÉ)³yV8 CLÄØÁ‘WYïi€H6ÖÑiámø^ÈY´°Ñ7¥Û*—Ñ©L«Qƒï—Ùrÿ ›£Ð*š¸ˆL©ˆ$ˆ ÷¾D§9È®«qbqC)–ˆïv´çñsÑVT­Ø, <àïºÀO«Jý·õ àfPìð .wFšir´þ’2_Y *Æ€x\« ì€9š@ Ž|F⇥ˆkZ@hÖÄ0t¿-<“‹qµ¾*ZL¤Ú)&BJpÓF5=$„at*Zš$’ÑtdûÝRI1 2Ž‰$€$I$#‰SÞ’Hë¬ï;Á$¡t$’`<(ñÇt)$‡Ð.Êf¢X’Kt=Éé$‚ˆªè¢oÝëòI%Rgcª÷ŠyI%¡‰ÿ !ñ)´õ $¤ Ô’IIGÿÙimport ast import _peg_parser as peg_parser import unittest from typing import Any, Union, Iterable, Tuple from textwrap import dedent from test import support TEST_CASES = [ ('annotated_assignment', 'x: int = 42'), ('annotated_assignment_with_tuple', 'x: tuple = 1, 2'), ('annotated_assignment_with_parens', '(paren): int = 3+2'), ('annotated_assignment_with_yield', 'x: int = yield 42'), ('annotated_no_assignment', 'x: int'), ('annotation_with_multiple_parens', '((parens)): int'), ('annotation_with_parens', '(parens): int'), ('annotated_assignment_with_attr', 'a.b: int'), ('annotated_assignment_with_subscript', 'a[b]: int'), ('annotated_assignment_with_attr_and_parens', '(a.b): int'), ('annotated_assignment_with_subscript_and_parens', '(a[b]): int'), ('assert', 'assert a'), ('assert_message', 'assert a, b'), ('assignment_false', 'a = False'), ('assignment_none', 'a = None'), ('assignment_true', 'a = True'), ('assignment_paren', '(a) = 42'), ('assignment_paren_multiple', '(a, b) = (0, 1)'), ('asyncfor', ''' async for i in a: pass '''), ('attribute_call', 'a.b()'), ('attribute_multiple_names', 'abcd.efg.hij'), ('attribute_simple', 'a.b'), ('attributes_subscript', 'a.b[0]'), ('augmented_assignment', 'x += 42'), ('augmented_assignment_attribute', 'a.b.c += 42'), ('augmented_assignment_paren', '(x) += 42'), ('augmented_assignment_paren_subscript', '(x[0]) -= 42'), ('binop_add', '1 + 1'), ('binop_add_multiple', '1 + 1 + 1 + 1'), ('binop_all', '1 + 2 * 5 + 3 ** 2 - -3'), ('binop_boolop_comp', '1 + 1 == 2 or 1 + 1 == 3 and not b'), ('boolop_or', 'a or b'), ('boolop_or_multiple', 'a or b or c'), ('class_def_bases', ''' class C(A, B): pass '''), ('class_def_decorators', ''' @a class C: pass '''), ('class_def_decorator_with_expression', ''' @lambda x: 42 class C: pass '''), ('class_def_decorator_with_expression_and_walrus', ''' @x:=lambda x: 42 class C: pass '''), ('class_def_keywords', ''' class C(keyword=a+b, **c): pass '''), ('class_def_mixed', ''' class C(A, B, keyword=0, **a): pass '''), ('class_def_simple', ''' class C: pass '''), ('class_def_starred_and_kwarg', ''' class C(A, B, *x, **y): pass '''), ('class_def_starred_in_kwargs', ''' class C(A, x=2, *[B, C], y=3): pass '''), ('call_attribute', 'f().b'), ('call_genexp', 'f(i for i in a)'), ('call_mixed_args', 'f(a, b, *c, **d)'), ('call_mixed_args_named', 'f(a, b, *c, d=4, **v)'), ('call_one_arg', 'f(a)'), ('call_posarg_genexp', 'f(a, (i for i in a))'), ('call_simple', 'f()'), ('call_subscript', 'f()[0]'), ('comp', 'a == b'), ('comp_multiple', 'a == b == c'), ('comp_paren_end', 'a == (b-1)'), ('comp_paren_start', '(a-1) == b'), ('decorator', ''' @a def f(): pass '''), ('decorator_async', ''' @a async def d(): pass '''), ('decorator_with_expression', ''' @lambda x: 42 def f(): pass '''), ('decorator_with_expression_and_walrus', ''' @x:=lambda x: 42 def f(): pass '''), ('del_attribute', 'del a.b'), ('del_call_attribute', 'del a().c'), ('del_call_genexp_attribute', 'del a(i for i in b).c'), ('del_empty', 'del()'), ('del_list', 'del a, [b, c]'), ('del_mixed', 'del a[0].b().c'), ('del_multiple', 'del a, b'), ('del_multiple_calls_attribute', 'del a()().b'), ('del_paren', 'del(a,b)'), ('del_paren_single_target', 'del(a)'), ('del_subscript_attribute', 'del a[0].b'), ('del_tuple', 'del a, (b, c)'), ('delete', 'del a'), ('dict', ''' { a: 1, b: 2, c: 3 } '''), ('dict_comp', '{x:1 for x in a}'), ('dict_comp_if', '{x:1+2 for x in a if b}'), ('dict_empty', '{}'), ('empty_line_after_linecont', r''' pass \ pass '''), ('for', ''' for i in a: pass '''), ('for_else', ''' for i in a: pass else: pass '''), ('for_star_target_in_paren', 'for (a) in b: pass'), ('for_star_targets_attribute', 'for a.b in c: pass'), ('for_star_targets_call_attribute', 'for a().c in b: pass'), ('for_star_targets_empty', 'for () in a: pass'), ('for_star_targets_mixed', 'for a[0].b().c in d: pass'), ('for_star_targets_mixed_starred', ''' for a, *b, (c, d) in e: pass '''), ('for_star_targets_multiple', 'for a, b in c: pass'), ('for_star_targets_nested_starred', 'for *[*a] in b: pass'), ('for_star_targets_starred', 'for *a in b: pass'), ('for_star_targets_subscript_attribute', 'for a[0].b in c: pass'), ('for_star_targets_trailing_comma', ''' for a, (b, c), in d: pass '''), ('for_star_targets_tuple', 'for a, (b, c) in d: pass'), ('for_underscore', ''' for _ in a: pass '''), ('function_return_type', ''' def f() -> Any: pass '''), ('f-string_slice', "f'{x[2]}'"), ('f-string_slice_upper', "f'{x[2:3]}'"), ('f-string_slice_step', "f'{x[2:3:-2]}'"), ('f-string_constant', "f'{42}'"), ('f-string_boolop', "f'{x and y}'"), ('f-string_named_expr', "f'{(x:=42)}'"), ('f-string_binop', "f'{x+y}'"), ('f-string_unaryop', "f'{not x}'"), ('f-string_lambda', "f'{(lambda x, /, y, y2=42 , *z, k1, k2=34, **k3: 42)}'"), ('f-string_lambda_call', "f'{(lambda: 2)(2)}'"), ('f-string_ifexpr', "f'{x if y else z}'"), ('f-string_dict', "f'{ {2:34, 3:34} }'"), ('f-string_set', "f'{ {2,-45} }'"), ('f-string_list', "f'{ [2,-45] }'"), ('f-string_tuple', "f'{ (2,-45) }'"), ('f-string_listcomp', "f'{[x for x in y if z]}'"), ('f-string_setcomp', "f'{ {x for x in y if z} }'"), ('f-string_dictcomp', "f'{ {x:x for x in y if z} }'"), ('f-string_genexpr', "f'{ (x for x in y if z) }'"), ('f-string_yield', "f'{ (yield x) }'"), ('f-string_yieldfrom', "f'{ (yield from x) }'"), ('f-string_await', "f'{ await x }'"), ('f-string_compare', "f'{ x == y }'"), ('f-string_call', "f'{ f(x,y,z) }'"), ('f-string_attribute', "f'{ f.x.y.z }'"), ('f-string_starred', "f'{ *x, }'"), ('f-string_doublestarred', "f'{ {**x} }'"), ('f-string_escape_brace', "f'{{Escape'"), ('f-string_escape_closing_brace', "f'Escape}}'"), ('f-string_multiline', """ f''' {hello} ''' """), ('f-string_multiline_in_expr', """ f''' { hello } ''' """), ('f-string_multiline_in_call', """ f''' {f( a, b, c )} ''' """), ('global', 'global a, b'), ('group', '(yield a)'), ('if_elif', ''' if a: pass elif b: pass '''), ('if_elif_elif', ''' if a: pass elif b: pass elif c: pass '''), ('if_elif_else', ''' if a: pass elif b: pass else: pass '''), ('if_else', ''' if a: pass else: pass '''), ('if_simple', 'if a: pass'), ('import', 'import a'), ('import_alias', 'import a as b'), ('import_dotted', 'import a.b'), ('import_dotted_alias', 'import a.b as c'), ('import_dotted_multichar', 'import ab.cd'), ('import_from', 'from a import b'), ('import_from_alias', 'from a import b as c'), ('import_from_dotted', 'from a.b import c'), ('import_from_dotted_alias', 'from a.b import c as d'), ('import_from_multiple_aliases', 'from a import b as c, d as e'), ('import_from_one_dot', 'from .a import b'), ('import_from_one_dot_alias', 'from .a import b as c'), ('import_from_star', 'from a import *'), ('import_from_three_dots', 'from ...a import b'), ('import_from_trailing_comma', 'from a import (b,)'), ('kwarg', ''' def f(**a): pass '''), ('kwonly_args', ''' def f(*, a, b): pass '''), ('kwonly_args_with_default', ''' def f(*, a=2, b): pass '''), ('lambda_kwarg', 'lambda **a: 42'), ('lambda_kwonly_args', 'lambda *, a, b: 42'), ('lambda_kwonly_args_with_default', 'lambda *, a=2, b: 42'), ('lambda_mixed_args', 'lambda a, /, b, *, c: 42'), ('lambda_mixed_args_with_default', 'lambda a, b=2, /, c=3, *e, f, **g: 42'), ('lambda_no_args', 'lambda: 42'), ('lambda_pos_args', 'lambda a,b: 42'), ('lambda_pos_args_with_default', 'lambda a, b=2: 42'), ('lambda_pos_only_args', 'lambda a, /: 42'), ('lambda_pos_only_args_with_default', 'lambda a=0, /: 42'), ('lambda_pos_posonly_args', 'lambda a, b, /, c, d: 42'), ('lambda_pos_posonly_args_with_default', 'lambda a, b=0, /, c=2: 42'), ('lambda_vararg', 'lambda *a: 42'), ('lambda_vararg_kwonly_args', 'lambda *a, b: 42'), ('list', '[1, 2, a]'), ('list_comp', '[i for i in a]'), ('list_comp_if', '[i for i in a if b]'), ('list_trailing_comma', '[1+2, a, 3+4,]'), ('mixed_args', ''' def f(a, /, b, *, c): pass '''), ('mixed_args_with_default', ''' def f(a, b=2, /, c=3, *e, f, **g): pass '''), ('multipart_string_bytes', 'b"Hola" b"Hello" b"Bye"'), ('multipart_string_triple', '"""Something here""" "and now"'), ('multipart_string_different_prefixes', 'u"Something" "Other thing" r"last thing"'), ('multiple_assignments', 'x = y = z = 42'), ('multiple_assignments_with_yield', 'x = y = z = yield 42'), ('multiple_pass', ''' pass; pass pass '''), ('namedexpr', '(x := [1, 2, 3])'), ('namedexpr_false', '(x := False)'), ('namedexpr_none', '(x := None)'), ('namedexpr_true', '(x := True)'), ('nonlocal', 'nonlocal a, b'), ('number_complex', '-2.234+1j'), ('number_float', '-34.2333'), ('number_imaginary_literal', '1.1234j'), ('number_integer', '-234'), ('number_underscores', '1_234_567'), ('pass', 'pass'), ('pos_args', ''' def f(a, b): pass '''), ('pos_args_with_default', ''' def f(a, b=2): pass '''), ('pos_only_args', ''' def f(a, /): pass '''), ('pos_only_args_with_default', ''' def f(a=0, /): pass '''), ('pos_posonly_args', ''' def f(a, b, /, c, d): pass '''), ('pos_posonly_args_with_default', ''' def f(a, b=0, /, c=2): pass '''), ('primary_mixed', 'a.b.c().d[0]'), ('raise', 'raise'), ('raise_ellipsis', 'raise ...'), ('raise_expr', 'raise a'), ('raise_from', 'raise a from b'), ('return', 'return'), ('return_expr', 'return a'), ('set', '{1, 2+4, 3+5}'), ('set_comp', '{i for i in a}'), ('set_trailing_comma', '{1, 2, 3,}'), ('simple_assignment', 'x = 42'), ('simple_assignment_with_yield', 'x = yield 42'), ('string_bytes', 'b"hello"'), ('string_concatenation_bytes', 'b"hello" b"world"'), ('string_concatenation_simple', '"abcd" "efgh"'), ('string_format_simple', 'f"hello"'), ('string_format_with_formatted_value', 'f"hello {world}"'), ('string_simple', '"hello"'), ('string_unicode', 'u"hello"'), ('subscript_attribute', 'a[0].b'), ('subscript_call', 'a[b]()'), ('subscript_multiple_slices', 'a[0:a:2, 1]'), ('subscript_simple', 'a[0]'), ('subscript_single_element_tuple', 'a[0,]'), ('subscript_trailing_comma', 'a[0, 1, 2,]'), ('subscript_tuple', 'a[0, 1, 2]'), ('subscript_whole_slice', 'a[0+1:b:c]'), ('try_except', ''' try: pass except: pass '''), ('try_except_else', ''' try: pass except: pass else: pass '''), ('try_except_else_finally', ''' try: pass except: pass else: pass finally: pass '''), ('try_except_expr', ''' try: pass except a: pass '''), ('try_except_expr_target', ''' try: pass except a as b: pass '''), ('try_except_finally', ''' try: pass except: pass finally: pass '''), ('try_finally', ''' try: pass finally: pass '''), ('unpacking_binop', '[*([1, 2, 3] + [3, 4, 5])]'), ('unpacking_call', '[*b()]'), ('unpacking_compare', '[*(x < y)]'), ('unpacking_constant', '[*3]'), ('unpacking_dict', '[*{1: 2, 3: 4}]'), ('unpacking_dict_comprehension', '[*{x:y for x,y in z}]'), ('unpacking_ifexpr', '[*([1, 2, 3] if x else y)]'), ('unpacking_list', '[*[1,2,3]]'), ('unpacking_list_comprehension', '[*[x for x in y]]'), ('unpacking_namedexpr', '[*(x:=[1, 2, 3])]'), ('unpacking_set', '[*{1,2,3}]'), ('unpacking_set_comprehension', '[*{x for x in y}]'), ('unpacking_string', '[*"myvalue"]'), ('unpacking_tuple', '[*(1,2,3)]'), ('unpacking_unaryop', '[*(not [1, 2, 3])]'), ('unpacking_yield', '[*(yield 42)]'), ('unpacking_yieldfrom', '[*(yield from x)]'), ('tuple', '(1, 2, 3)'), ('vararg', ''' def f(*a): pass '''), ('vararg_kwonly_args', ''' def f(*a, b): pass '''), ('while', ''' while a: pass '''), ('while_else', ''' while a: pass else: pass '''), ('with', ''' with a: pass '''), ('with_as', ''' with a as b: pass '''), ('with_as_paren', ''' with a as (b): pass '''), ('with_as_empty', 'with a as (): pass'), ('with_list_recursive', ''' with a as [x, [y, z]]: pass '''), ('with_tuple_recursive', ''' with a as ((x, y), z): pass '''), ('with_tuple_target', ''' with a as (x, y): pass '''), ('with_list_target', ''' with a as [x, y]: pass '''), ('yield', 'yield'), ('yield_expr', 'yield a'), ('yield_from', 'yield from a'), ] FAIL_TEST_CASES = [ ("annotation_multiple_targets", "(a, b): int = 42"), ("annotation_nested_tuple", "((a, b)): int"), ("annotation_list", "[a]: int"), ("annotation_lambda", "lambda: int = 42"), ("annotation_tuple", "(a,): int"), ("annotation_tuple_without_paren", "a,: int"), ("assignment_keyword", "a = if"), ("augmented_assignment_list", "[a, b] += 1"), ("augmented_assignment_tuple", "a, b += 1"), ("augmented_assignment_tuple_paren", "(a, b) += (1, 2)"), ("comprehension_lambda", "(a for a in lambda: b)"), ("comprehension_else", "(a for a in b if c else d"), ("del_call", "del a()"), ("del_call_genexp", "del a(i for i in b)"), ("del_subscript_call", "del a[b]()"), ("del_attribute_call", "del a.b()"), ("del_mixed_call", "del a[0].b().c.d()"), ("for_star_targets_call", "for a() in b: pass"), ("for_star_targets_subscript_call", "for a[b]() in c: pass"), ("for_star_targets_attribute_call", "for a.b() in c: pass"), ("for_star_targets_mixed_call", "for a[0].b().c.d() in e: pass"), ("for_star_targets_in", "for a, in in b: pass"), ("f-string_assignment", "f'{x = 42}'"), ("f-string_empty", "f'{}'"), ("f-string_function_def", "f'{def f(): pass}'"), ("f-string_lambda", "f'{lambda x: 42}'"), ("f-string_singe_brace", "f'{'"), ("f-string_single_closing_brace", "f'}'"), ("from_import_invalid", "from import import a"), ("from_import_trailing_comma", "from a import b,"), ("import_non_ascii_syntax_error", "import ä £"), # This test case checks error paths involving tokens with uninitialized # values of col_offset and end_col_offset. ("invalid indentation", """ def f(): a a """), ("not_terminated_string", "a = 'example"), ("try_except_attribute_target", """ try: pass except Exception as a.b: pass """), ("try_except_subscript_target", """ try: pass except Exception as a[0]: pass """), ] FAIL_SPECIALIZED_MESSAGE_CASES = [ ("f(x, y, z=1, **b, *a", "iterable argument unpacking follows keyword argument unpacking"), ("f(x, y=1, *z, **a, b", "positional argument follows keyword argument unpacking"), ("f(x, y, z=1, a=2, b", "positional argument follows keyword argument"), ("True = 1", "cannot assign to True"), ("a() = 1", "cannot assign to function call"), ("(a, b): int", "only single target (not tuple) can be annotated"), ("[a, b]: int", "only single target (not list) can be annotated"), ("a(): int", "illegal target for annotation"), ("1 += 1", "'literal' is an illegal expression for augmented assignment"), ("pass\n pass", "unexpected indent"), ("def f():\npass", "expected an indented block"), ("def f(*): pass", "named arguments must follow bare *"), ("def f(*,): pass", "named arguments must follow bare *"), ("def f(*, **a): pass", "named arguments must follow bare *"), ("lambda *: pass", "named arguments must follow bare *"), ("lambda *,: pass", "named arguments must follow bare *"), ("lambda *, **a: pass", "named arguments must follow bare *"), ("f(g()=2", "expression cannot contain assignment, perhaps you meant \"==\"?"), ("f(a, b, *c, d.e=2", "expression cannot contain assignment, perhaps you meant \"==\"?"), ("f(*a, **b, c=0, d[1]=3)", "expression cannot contain assignment, perhaps you meant \"==\"?"), ] GOOD_BUT_FAIL_TEST_CASES = [ ('string_concatenation_format', 'f"{hello} world" f"again {and_again}"'), ('string_concatenation_multiple', ''' f"hello" f"{world} again" f"and_again" '''), ('f-string_multiline_comp', """ f''' {(i for i in a if b)} ''' """), ] FSTRINGS_TRACEBACKS = { 'multiline_fstrings_same_line_with_brace': ( """ f''' {a$b} ''' """, '(a$b)\n', ), 'multiline_fstring_brace_on_next_line': ( """ f''' {a$b }''' """, '(a$b\n', ), 'multiline_fstring_brace_on_previous_line': ( """ f''' { a$b}''' """, 'a$b)\n', ), } EXPRESSIONS_TEST_CASES = [ ("expression_add", "1+1"), ("expression_add_2", "a+b"), ("expression_call", "f(a, b=2, **kw)"), ("expression_tuple", "1, 2, 3"), ("expression_tuple_one_value", "1,") ] def cleanup_source(source: Any) -> str: if isinstance(source, str): result = dedent(source) elif not isinstance(source, (list, tuple)): result = "\n".join(source) else: raise TypeError(f"Invalid type for test source: {source}") return result def prepare_test_cases( test_cases: Iterable[Tuple[str, Union[str, Iterable[str]]]] ) -> Tuple[Iterable[str], Iterable[str]]: test_ids, _test_sources = zip(*test_cases) test_sources = list(_test_sources) for index, source in enumerate(test_sources): result = cleanup_source(source) test_sources[index] = result return test_ids, test_sources TEST_IDS, TEST_SOURCES = prepare_test_cases(TEST_CASES) GOOD_BUT_FAIL_TEST_IDS, GOOD_BUT_FAIL_SOURCES = prepare_test_cases( GOOD_BUT_FAIL_TEST_CASES ) FAIL_TEST_IDS, FAIL_SOURCES = prepare_test_cases(FAIL_TEST_CASES) EXPRESSIONS_TEST_IDS, EXPRESSIONS_TEST_SOURCES = prepare_test_cases( EXPRESSIONS_TEST_CASES ) class ASTGenerationTest(unittest.TestCase): def test_correct_ast_generation_on_source_files(self) -> None: self.maxDiff = None for source in TEST_SOURCES: actual_ast = peg_parser.parse_string(source) expected_ast = peg_parser.parse_string(source, oldparser=True) self.assertEqual( ast.dump(actual_ast, include_attributes=True), ast.dump(expected_ast, include_attributes=True), f"Wrong AST generation for source: {source}", ) def test_incorrect_ast_generation_on_source_files(self) -> None: for source in FAIL_SOURCES: with self.assertRaises(SyntaxError, msg=f"Parsing {source} did not raise an exception"): peg_parser.parse_string(source) def test_incorrect_ast_generation_with_specialized_errors(self) -> None: for source, error_text in FAIL_SPECIALIZED_MESSAGE_CASES: exc = IndentationError if "indent" in error_text else SyntaxError with self.assertRaises(exc) as se: peg_parser.parse_string(source) self.assertTrue( error_text in se.exception.msg, f"Actual error message does not match expexted for {source}" ) @unittest.expectedFailure def test_correct_but_known_to_fail_ast_generation_on_source_files(self) -> None: for source in GOOD_BUT_FAIL_SOURCES: actual_ast = peg_parser.parse_string(source) expected_ast = peg_parser.parse_string(source, oldparser=True) self.assertEqual( ast.dump(actual_ast, include_attributes=True), ast.dump(expected_ast, include_attributes=True), f"Wrong AST generation for source: {source}", ) def test_correct_ast_generation_without_pos_info(self) -> None: for source in GOOD_BUT_FAIL_SOURCES: actual_ast = peg_parser.parse_string(source) expected_ast = peg_parser.parse_string(source, oldparser=True) self.assertEqual( ast.dump(actual_ast), ast.dump(expected_ast), f"Wrong AST generation for source: {source}", ) def test_fstring_parse_error_tracebacks(self) -> None: for source, error_text in FSTRINGS_TRACEBACKS.values(): with self.assertRaises(SyntaxError) as se: peg_parser.parse_string(dedent(source)) self.assertEqual(error_text, se.exception.text) def test_correct_ast_generatrion_eval(self) -> None: for source in EXPRESSIONS_TEST_SOURCES: actual_ast = peg_parser.parse_string(source, mode='eval') expected_ast = peg_parser.parse_string(source, mode='eval', oldparser=True) self.assertEqual( ast.dump(actual_ast, include_attributes=True), ast.dump(expected_ast, include_attributes=True), f"Wrong AST generation for source: {source}", ) def test_tokenizer_errors_are_propagated(self) -> None: n=201 with self.assertRaisesRegex(SyntaxError, "too many nested parentheses"): peg_parser.parse_string(n*'(' + ')'*n)