Ë
    pPêjß  ã                  óÄ  — U d dl mZ d dlZd dlZd dlZd dlmZ d dlm	Z	m
Z
mZ d dlmZ d dlmZmZmZmZmZ d dlmZ d dlmZmZmZmZmZmZ d d	lm Z! d d
l"m#Z#mZm$Z$m%Z%m&Z&mZm'Z'm(Z(m)Z) d dl*m+Z+ d dl,m-Z-m.Z.m/Z/m0Z0m1Z1 d dl2m3Z3 d dl4m5Z5 d dl6m7Z7 d dl8m9Z9 d dl:m;Z; d dl<m=Z>  ed«      Z?e!j€                  j‚                  e!j„                  j‚                  hZCdeDd<   e!jŠ                  e!jŒ                  e!jŽ                  e!j�                  e!j’                  e!j”                  e!j–                  hZLdeDd<   dZMdeDd<   e!jœ                  e!jŠ                  e!jž                  e!jŠ                  iZPdeDd<    G d„ d«      ZQ G d„ d«      ZR G d„ d«      ZS G d „ d!«      ZT G d"„ d#eR«      ZU G d$„ d%«      ZV G d&„ d'eW«      ZXd-d(„ZY	 	 d.	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d/d)„ZZ G d*„ d+«      Z[e\e]e^e^f   Z_d0d,„Z`y)1é    )ÚannotationsN)Údefaultdict)ÚCallableÚIterableÚIterator)Úchain)ÚFinalÚLiteralÚNoReturnÚTextIOÚTypeVar)ÚSelf)Ú
ReadBufferÚWriteBufferÚ	read_boolÚread_intÚ
write_boolÚ	write_int)Ú
errorcodes)	Ú
ErrorTupler   Úread_int_listÚread_strÚread_str_optr   Úwrite_int_listÚ	write_strÚwrite_str_opt)ÚErrorFormatter)ÚIMPORTÚIMPORT_NOT_FOUNDÚIMPORT_UNTYPEDÚ	ErrorCodeÚmypy_error_codes)ÚContext)ÚOptions)ÚScope)ÚType)ÚDEFAULT_SOURCE_OFFSET)Ú__version__ÚTr	   ÚSHOW_NOTE_CODESÚHIDE_LINK_CODESz.https://mypy.rtfd.io/en/stable/_refs.html#codeÚBASE_RTD_URLÚoriginal_error_codesc                  óü   — e Zd ZU dZded<   ded<   dZdZdZdZdZ	dZ
dZd	ed
<   dZdZded<   ded<   ded<   ded<   dZdZded<   ddddœ	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dd„Zdd„Zedd„«       Zy)Ú	ErrorInfoz)Representation of a single error message.úlist[tuple[str, int]]Ú
import_ctxútuple[str | None, str | None]Ú	local_ctxr   Ú NúErrorCode | NoneÚcodeFú
str | NoneÚmoduleÚtargetzIterable[int]Úorigin_spanÚintÚpriorityúErrorInfo | NoneÚparent_error)r:   r<   r>   c               ó
  — || _         || _        || _        || _        || _        || _        || _        || _        || _        |	| _	        |
| _
        || _        |xs |g| _        || _        || _        |�|dk(  sJ d«       ‚|| _        y )NÚnotez$Only notes can specify parent errors)r1   r8   r3   ÚlineÚcolumnÚend_lineÚ
end_columnÚseverityÚmessager6   ÚblockerÚ	only_oncer:   r9   r<   r>   )Úselfr1   r3   rA   rB   rC   rD   rE   rF   r6   rG   rH   r8   r9   r:   r<   r>   s                    úP/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/mypy/errors.pyÚ__init__zErrorInfo.__init__x   s—   € ð( %ˆŒØˆŒØ"ˆŒØˆŒ	ØˆŒØ ˆŒØ$ˆŒØ ˆŒØˆŒØˆŒ	ØˆŒØ"ˆŒØ&Ò0¨4¨&ˆÔØˆŒØ ˆŒØÐ#Ø˜vÒ%ÐMÐ'MÓMÐ%Ø(ˆÕó    c                óŒ  — | j                   �J d«       ‚t        |t        | j                  «      «       | j                  D ]  \  }}t	        ||«       t        ||«       Œ | j                  \  }}t        ||«       t        ||«       t        || j                  «       t        || j                  «       t        || j                  «       t        || j                  «       t	        || j                  «       t	        || j                  «       t        || j                  r| j                  j                  nd «       t        || j                   «       t        || j"                  «       t        || j$                  «       t        || j&                  «       t)        |t+        | j,                  «      «       t        || j.                  «       y )NzParent errors not supported yet)r>   Úwrite_int_bareÚlenr1   r   r   r3   r   rA   rB   rC   rD   rE   rF   r6   r   rG   rH   r8   r9   r   Úlistr:   r<   )rI   ÚbufÚfilerA   ÚtypeÚfunctions         rJ   ÚwritezErrorInfo.writeŸ   sD  € Ø× Ñ Ð(ÐKÐ*KÓKÐ(Ü�sœC §¡Ó0Ô1ØŸ/™/ò 	!‰JˆD�$Ü�c˜4Ô Ü�c˜4Õ ð	!ð Ÿ™‰ˆˆhÜ�c˜4Ô Ü�c˜8Ô$Ü�#�t—y‘yÔ!Ü�#�t—{‘{Ô#Ü�#�t—}‘}Ô%Ü�#�t—‘Ô'Ü�#�t—}‘}Ô%Ü�#�t—|‘|Ô$Ü�c¨T¯YªY˜4Ÿ9™9Ÿ>š>¸DÔAÜ�3˜Ÿ™Ô%Ü�3˜Ÿ™Ô'Ü�c˜4Ÿ;™;Ô'Ü�c˜4Ÿ;™;Ô'Ü�sœD ×!1Ñ!1Ó2Ô3Ü�#�t—}‘}Õ%rL   c                óÔ  — t        t        t        |«      «      D �cg c]  }t        |«      t	        |«      f‘Œ c}t        |«      t        |«      ft	        |«      t	        |«      t	        |«      t	        |«      t        |«      t        |«      t        |«      x}r	t        |   nd t        |«      t        |«      t        |«      t        |«      t        |«      t	        |«      ¬«      S c c}w )N©r1   r3   rA   rB   rC   rD   rE   rF   r6   rG   rH   r8   r9   r:   r<   )	r/   ÚrangeÚread_int_barer   r   r   r"   r   r   )ÚclsrQ   Ú_r6   s       rJ   ÚreadzErrorInfo.read¶   s»   € äÜ@EÄmÐTWÓFXÓ@YÖZ¸1œ #›¬°«Ò6ÒZÜ# CÓ(¬,°sÓ*;Ð<Ü˜#“Ü˜C“=Ü˜c“]Ü “}Ü˜c“]Ü˜S“MÜ4@ÀÓ4EÐ,E¨DÐ,EÔ! $Ò'ÈDÜ˜c“NÜ “nÜ Ó$Ü Ó$Ü% cÓ*Ü˜c“]ô
ð 	
ùÚZs   œC%)"r1   r0   r3   r2   rA   r;   rB   r;   rC   r;   rD   r;   rE   ÚstrrF   r]   r6   r5   rG   ÚboolrH   r^   r8   r7   r9   r7   r:   úIterable[int] | Noner<   r;   r>   r=   ÚreturnÚNone)rQ   r   r`   ra   )rQ   r   r`   r/   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__Ú__annotations__rA   rB   rC   rD   rE   rF   r6   rG   rH   Úhiddenr>   rK   rU   Úclassmethodr\   © rL   rJ   r/   r/   G   sM  … Ù3ð &Ó%à,Ó,ð €Dà€Fà€Hà€Jà€Hà€Gà!€DÐ
Ó!ð €Gà€Ið ÓàÓð
 Óð ƒMà€Fð &*€LÐ"Ó)ð$ -1ØØ)-ñ%%)ð *ð%)ð 1ð	%)ð
 ð%)ð ð%)ð ð%)ð ð%)ð ð%)ð ð%)ð ð%)ð ð%)ð ð%)ð ð%)ð ð%)ð  *ð!%)ð" ð#%)ð$ 'ð%%)ð& 
ó'%)óN&ð. ò
ó ñ
rL   r/   c                  ón   — e Zd ZU dZded<   dddddœ	 	 	 	 	 	 	 	 	 	 	 dd„Zdd„Zdd„Zdd	„Zdd
„Z	dd„Z
y)ÚErrorWatchera2  Context manager that can be used to keep track of new errors recorded
    around a given operation.

    Errors maintain a stack of such watchers. The handler is called starting
    at the top of the stack, and is propagated down the stack unless filtered
    out by one of the ErrorWatcher instances.
    r^   Úfilter_revealed_typeF)Úfilter_errorsÚsave_filtered_errorsÚfilter_deprecatedrl   c               ól   — || _         d| _        || _        || _        || _        |rg | _        y d | _        y ©NF)ÚerrorsÚ_has_new_errorsÚ_filterÚ_filter_deprecatedrl   Ú	_filtered)rI   rr   rm   rn   ro   rl   s         rJ   rK   zErrorWatcher.__init__Ø   s:   € ð ˆŒØ$ˆÔØ$ˆŒØ"3ˆÔØ$8ˆÔ!Ù7K°ˆ�ÐQUˆ�rL   c                óP   — | j                   j                  j                  | «       | S ©N)rr   Ú	_watchersÚappend©rI   s    rJ   Ú	__enter__zErrorWatcher.__enter__è   s   € Ø�‰×Ñ×$Ñ$ TÔ*ØˆrL   c                óZ   — | j                   j                  j                  «       }|| k(  sJ ‚yrq   )rr   ry   Úpop)rI   Úexc_typeÚexc_valÚexc_tbÚlasts        rJ   Ú__exit__zErrorWatcher.__exit__ì   s)   € Ø�{‰{×$Ñ$×(Ñ(Ó*ˆØ�tŠ|Ðˆ|ØrL   c                óš  — |j                   t        j                  k(  r| j                  syd| _        t        | j                  t        «      r| j                  }nIt        | j                  «      r| j                  ||«      }n!t        dt        | j                  «      › �«      ‚|r'| j                  �| j                  j                  |«       |S )a  Handler called when a new error is recorded.

        The default implementation just sets the has_new_errors flag

        Return True to filter out the error, preventing it from being seen by other
        ErrorWatcher further down the stack and from being recorded by Errors
        FTzinvalid error filter: )r6   ÚcodesÚ
DEPRECATEDru   rs   Ú
isinstancert   r^   ÚcallableÚAssertionErrorrS   rv   rz   )rI   rR   ÚinfoÚshould_filters       rJ   Úon_errorzErrorWatcher.on_errorñ   sž   € ð �9‰9œ×(Ñ(Ò(à×*Ò*Øà#ˆÔÜ�d—l‘l¤DÔ)Ø ŸL™L‰MÜ�d—l‘lÔ#Ø ŸL™L¨¨tÓ4‰Mä Ð#9¼$¸t¿|¹|Ó:LÐ9MÐ!NÓOÐOÙ˜TŸ^™^Ð7Ø�N‰N×!Ñ! $Ô'àÐrL   c                ó   — | j                   S rx   )rs   r{   s    rJ   Úhas_new_errorszErrorWatcher.has_new_errors
  s   € Ø×#Ñ#Ð#rL   c                ó6   — | j                   €J ‚| j                   S rx   )rv   r{   s    rJ   Úfiltered_errorszErrorWatcher.filtered_errors  s   € Ø�~‰~Ð)Ð)Ð)Ø�~‰~ÐrL   N)rr   ÚErrorsrm   ú'bool | Callable[[str, ErrorInfo], bool]rn   r^   ro   r^   rl   r^   r`   ra   )r`   r   )r   Úobjectr€   r“   r�   r“   r`   zLiteral[False]©rR   r]   rŠ   r/   r`   r^   ©r`   r^   )r`   úlist[ErrorInfo])rb   rc   rd   re   rf   rK   r|   rƒ   rŒ   rŽ   r�   ri   rL   rJ   rk   rk   Ë   s~   … ñð Óð BGØ%*Ø"'Ø%*ñVàðVð ?ð	Vð
 #ðVð  ðVð #ðVð 
óVó óó
ó2$ôrL   rk   c                  óp   — e Zd ZU ded<   ded<   ded<   ded<   ded<   	 	 	 	 	 	 	 	 	 	 	 	 dd	„Zdd
„Zdd„Zy)ÚNonOverlapErrorInfor;   rA   rB   ú
int | NonerC   rD   r]   Úkindc               óJ   — || _         || _        || _        || _        || _        y rx   )rA   rB   rC   rD   rš   )rI   rA   rB   rC   rD   rš   s         rJ   rK   zNonOverlapErrorInfo.__init__  s'   € ð ˆŒ	ØˆŒØ ˆŒØ$ˆŒØˆ�	rL   c                ó.  — t        |t        «      r…| j                  |j                  k(  xrj | j                  |j                  k(  xrO | j                  |j                  k(  xr4 | j
                  |j
                  k(  xr | j                  |j                  k(  S yrq   )r‡   r˜   rA   rB   rC   rD   rš   )rI   Úothers     rJ   Ú__eq__zNonOverlapErrorInfo.__eq__"  s�   € Ü�eÔ0Ô1à—	‘	˜UŸZ™ZÑ'ò ,Ø—K‘K 5§<¡<Ñ/ò,à—M‘M U§^¡^Ñ3ò,ð —O‘O u×'7Ñ'7Ñ7ò,ð —I‘I §¡Ñ+ðð rL   c                ó†   — t        | j                  | j                  | j                  | j                  | j
                  f«      S rx   )ÚhashrA   rB   rC   rD   rš   r{   s    rJ   Ú__hash__zNonOverlapErrorInfo.__hash__-  s,   € Ü�T—Y‘Y §¡¨T¯]©]¸D¿O¹OÈTÏYÉYÐWÓXÐXrL   N)rA   r;   rB   r;   rC   r™   rD   r™   rš   r]   r`   ra   )r�   r“   r`   r^   ©r`   r;   )rb   rc   rd   rf   rK   rž   r¡   ri   rL   rJ   r˜   r˜     s]   … Ø
ƒIØƒKØÓØÓØ
ƒIðØðØ$'ðØ3=ðØKUðØ]`ðà	óó	ôYrL   r˜   c                  ó^   — e Zd ZU dZded<   ded<   ded<   ded	<   dd
„Zdd„Z	 	 dd„Zdd„Zy)ÚIterationDependentErrorsa+  An `IterationDependentErrors` instance serves to collect the `unreachable`,
    `redundant-expr`, and `redundant-casts` errors, as well as the revealed types and
    non-overlapping types, handled by the individual `IterationErrorWatcher` instances
    sequentially applied to the same code section.z4list[set[tuple[ErrorCode, str, int, int, int, int]]]Úuselessness_errorszlist[set[int]]Úunreachable_linesz9dict[tuple[int, int, int | None, int | None], list[Type]]Úrevealed_typesz2list[dict[NonOverlapErrorInfo, tuple[Type, Type]]]Únonoverlapping_typesc                óV   — g | _         g | _        g | _        t        t        «      | _        y rx   )r¥   r¦   r¨   r   rP   r§   r{   s    rJ   rK   z!IterationDependentErrors.__init__H  s'   € Ø"$ˆÔØ!#ˆÔØ$&ˆÔ!Ü)¬$Ó/ˆÕrL   c              #  ó`  ‡K  — t        «       }t        t        | j                  Ž «      D ]F  Št        ˆfd„t	        | j                  | j
                  «      D «       «      sŒ6|j                  ‰«       ŒH |D ]6  }t        |d   |d   ¬«      }|d   |_        |d   |_	        |d   ||d   f–— Œ8 y	­w)
zŠReport only those `unreachable`, `redundant-expr`, and `redundant-casts`
        errors that could not be ruled out in any iteration step.c              3  ó>   •K  — | ]  \  }}‰|v xs ‰d    |v –— Œ y­w)é   Nri   )Ú.0rr   ÚlinesÚ	candidates      €rJ   ú	<genexpr>zIIterationDependentErrors.yield_uselessness_error_infos.<locals>.<genexpr>T  s3   øè ø€ ò á!�F˜Eð ˜fÐ$Ò@¨)°A©,¸%Ð*?Ó@ñùs   ƒr¬   é   ©rA   rB   é   é   é   r   N)
Úsetr   r¥   ÚallÚzipr¦   Úaddr#   rC   rD   )rI   Úpersistent_uselessness_errorsÚ
error_infoÚcontextr¯   s       @rJ   Úyield_uselessness_error_infosz6IterationDependentErrors.yield_uselessness_error_infosN  sº   øè ø€ ô ),«Ð%ÜœU D×$;Ñ$;Ð<Ó=ò 	=ˆIÜó ä%(¨×)@Ñ)@À$×BXÑBXÓ%Yôõ ð .×1Ñ1°)Õ<ð	=ð 8ò 	8ˆJÜ :¨a¡=¸ÀA¹ÔGˆGØ)¨!™}ˆGÔØ!+¨A¡ˆGÔØ˜Q‘- ¨*°Q©-Ð7Ó7ñ		8ùs   ƒAB.ÁAB.c              #  óÀ  ‡	K  — t        «       }t        t        j                  | j                  «      «      D ]F  Š	t	        ˆ	fd„t        | j                  | j                  «      D «       «      sŒ6|j                  ‰	«       ŒH t        d„ «      }| j                  D ]O  }|j                  «       D ]:  \  Š	\  }}‰	|v sŒ|‰	   }|d   j                  |«       |d   j                  |«       Œ< ŒQ |j                  «       D ]a  \  }}t        |j                  |j                  ¬«      }|j                  |_        |j                  |_        |d   |d   f|j                   |f–— Œc y­w)zzReport expressions where non-overlapping types were detected for all iterations
        were the expression was reachable.c              3  óL   •K  — | ]  \  }}‰|v xs ‰j                   |v –— Œ y ­wrx   )rA   )r­   Ú
nonoverlapr®   r¯   s      €rJ   r°   zFIterationDependentErrors.yield_nonoverlapping_types.<locals>.<genexpr>g  s3   øè ø€ ò á%�J ð ˜jÐ(ÒF¨i¯n©nÀÐ.EÓFñùs   ƒ!$c                 ó
   — g g fS rx   ri   ri   rL   rJ   ú<lambda>zEIterationDependentErrors.yield_nonoverlapping_types.<locals>.<lambda>n  s
   €   R € rL   r   rµ   r²   N)r¶   r   Úfrom_iterabler¨   r·   r¸   r¦   r¹   r   Úitemsrz   r#   rA   rB   rC   rD   rš   )
rI   ÚselectedÚpersistent_nonoverlapsÚnonoverlapsÚleftÚrightÚtypesr»   r¼   r¯   s
            @rJ   Úyield_nonoverlapping_typesz3IterationDependentErrors.yield_nonoverlapping_types_  sV  øè ø€ ô “5ˆÜœU×0Ñ0°×1JÑ1JÓKÓLò 	(ˆIÜó ä),¨T×-FÑ-FÈ×H^ÑH^Ó)_ôõ ð —‘˜YÕ'ð	(ô Ñ(Ó)ð 	ð  ×4Ñ4ò 	+ˆKØ,7×,=Ñ,=Ó,?ò +Ñ(�	™=˜D %Ø Ò(Ø2°9Ñ=�EØ˜!‘H—O‘O DÔ)Ø˜!‘H—O‘O EÕ*ñ	+ð	+ð "8×!=Ñ!=Ó!?ò 	AÑˆJ˜Ü :§?¡?¸:×;LÑ;LÔMˆGØ)×2Ñ2ˆGÔØ!+×!6Ñ!6ˆGÔØ˜‘8˜U 1™XÐ&¨
¯©¸Ð@Ó@ñ		Aùs   ƒA(EÁ,AEÂ8B&Ec              #  óª   K  — | j                   j                  «       D ]2  \  }}t        |d   |d   ¬«      }|d   |_        |d   |_        ||f–— Œ4 y­w)z8Yield all types revealed in at least one iteration step.r   rµ   r²   r¬   r±   N)r§   rÄ   r#   rC   rD   )rI   Ú	note_inforÊ   r¼   s       rJ   Úyield_revealed_type_infosz2IterationDependentErrors.yield_revealed_type_infos}  sa   è ø€ ð !%× 3Ñ 3× 9Ñ 9Ó ;ò 	!ÑˆI�uÜ 9¨Q¡<¸	À!¹ÔEˆGØ(¨™|ˆGÔØ!*¨1¡ˆGÔØ˜�.Ó ñ		!ùs   ‚AAN©r`   ra   )r`   z(Iterator[tuple[str, Context, ErrorCode]])r`   z<Iterator[tuple[tuple[list[Type], list[Type]], str, Context]])r`   z$Iterator[tuple[list[Type], Context]])	rb   rc   rd   re   rf   rK   r½   rË   rÎ   ri   rL   rJ   r¤   r¤   1  sH   … ñ6ð MÓLð &Ó%ð
 NÓMð MÓLó0ó8ð"Aà	EóAô<!rL   r¤   c                  ó\   ‡ — e Zd ZU dZded<   ddddœ	 	 	 	 	 	 	 	 	 	 	 dˆ fd„Zd	ˆ fd„Zˆ xZS )
ÚIterationErrorWatchera  Error watcher that filters and separately collects `unreachable` errors,
    `redundant-expr` and `redundant-casts` errors, and revealed types and
    non-overlapping types when analysing code sections iteratively to help avoid
    making too-hasty reports.r¤   Úiteration_dependent_errorsF©rm   rn   ro   c               óü   •— t         ‰| �  ||||¬«       || _        |j                  j	                  t        «       «       |j                  j	                  i «       |j                  j	                  t        «       «       y )NrÓ   )ÚsuperrK   rÒ   r¥   rz   r¶   r¨   r¦   )rI   rr   rÒ   rm   rn   ro   Ú	__class__s         €rJ   rK   zIterationErrorWatcher.__init__�  sn   ø€ ô 	‰ÑØØ'Ø!5Ø/ð	 	ô 	
ð +EˆÔ'Ø"×5Ñ5×<Ñ<¼S»UÔCØ"×7Ñ7×>Ñ>¸rÔBØ"×4Ñ4×;Ñ;¼C»EÕBrL   c                ó,  •— | j                   }|j                  t        j                  t        j                  t        j
                  fv r½|j                  d   j                  |j                  |j                  |j                  |j                  |j                  |j                  f«       |j                  t        j                  k(  r?|j                  d   j                  t        |j                  |j                  dz   «      «       yt         ‰| �E  ||«      S )z†Filter out the "iteration-dependent" errors and notes and store their
        information to handle them after iteration is completed.éÿÿÿÿrµ   T)rÒ   r6   r…   ÚUNREACHABLEÚREDUNDANT_EXPRÚREDUNDANT_CASTr¥   r¹   rF   rA   rB   rC   rD   r¦   ÚupdaterX   rÕ   rŒ   )rI   rR   rŠ   Úiter_errorsrÖ   s       €rJ   rŒ   zIterationErrorWatcher.on_error£  sÐ   ø€ ð ×5Ñ5ˆà�9‰9œ×*Ñ*¬E×,@Ñ,@Ä%×BVÑBVÐWÑWØ×*Ñ*¨2Ñ.×2Ñ2Ø—‘˜DŸL™L¨$¯)©)°T·[±[À$Ç-Á-ÐQU×Q`ÑQ`Ðaôð �y‰yœE×-Ñ-Ò-Ø×-Ñ-¨bÑ1×8Ñ8¼¸t¿y¹yÈ$Ï-É-ÐZ[ÑJ[Ó9\Ô]Øä‰wÑ  dÓ+Ð+rL   )rr   r‘   rÒ   r¤   rm   r’   rn   r^   ro   r^   r`   ra   r”   )rb   rc   rd   re   rf   rK   rŒ   Ú__classcell__©rÖ   s   @rJ   rÑ   rÑ   ‡  sm   ø… ñ!ð
 !9Ó8ð BGØ%*Ø"'ñCàðCð %=ðCð
 ?ðCð #ðCð  ðCð 
õC÷(,ñ ,rL   rÑ   c            
      ó  — e Zd ZU dZded<   ded<   ded<   ded<   d	Zd
ed<   dZded<   ded<   ded<   ded<   ded<   ded<   d	Zd
ed<   d	Zded<   dZ	dZ
ded<   ded<   d	d	d	dœ	 	 	 	 	 	 	 	 	 dNd„ZdOd„ZdOd „ZdPd!„ZdQd"„Z	 dR	 	 	 	 	 	 	 	 	 dSd#„Z	 dT	 	 	 	 	 	 	 dUd$„ZdVd%„ZdWd&„ZdWd'„ZdXd(„ZdYd)„Z	 dRdd*dd	d+d	d	d	d,œ	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dZd-„Zd[d.„Zdd+d/œ	 	 	 	 	 	 	 	 	 	 	 	 	 d\d0„Z	 	 	 	 	 	 	 	 	 	 d]d1„Zd^d2„Zd_d3„Zd	d4œd`d5„Zdad6„Zd[d7„Zdbd8„Z dcd9„Z!ddd:„Z"dTded;„Z#	 dT	 	 	 	 	 	 	 dfd<„Z$dgd=„Z%dad>„Z&dad?„Z'dWd@„Z(dhdA„Z)dadB„Z*didjdC„Z+	 	 	 	 	 	 dkdD„Z,dldE„Z-	 dR	 	 	 	 	 	 	 dmdF„Z.dndG„Z/dodH„Z0dpdI„Z1dqdJ„Z2drdK„Z3drdL„Z4drdM„Z5y	)sr‘   z“Container for compile errors.

    This class generates and keeps tracks of compile errors and the
    current error context (nested imports).
    zdict[str, list[ErrorInfo]]Úerror_info_mapúset[str]Úhas_blockersÚflushed_filesr0   r1   Nr7   Úignore_prefixr4   r]   rR   zdict[str, dict[int, list[str]]]Úignored_lineszdict[str, set[int]]Úskipped_linesÚused_ignored_linesÚignored_filesÚonly_once_messagesÚtarget_moduleúScope | NoneÚscopeFÚrecordedzlist[ErrorWatcher]ry   )Úread_sourceÚhide_error_codesÚerror_formatterc               óx   — || _         |�|n|j                  | _        || _        || _        | j	                  «        y rx   )Úoptionsrð   rï   rñ   Ú
initialize)rI   ró   rï   rð   rñ   s        rJ   rK   zErrors.__init__ñ  s@   € ð ˆŒà 0Ð <ÑÀ'×BZÑBZð 	Ôð 'ˆÔØ.ˆÔØ�‰ÕrL   c                óT  — i | _         t        «       | _        g | _        d g| _        i | _        i | _        t        d„ «      | _        t        «       | _	        t        «       | _
        t        «       | _        d | _        d | _        d| _        g | _        d| _        t        t"        «      | _        y )Nc                 ó    — t        t        «      S rx   )r   rP   ri   rL   rJ   rÂ   z#Errors.initialize.<locals>.<lambda>	  s   € ´kÄ$Ó6G€ rL   F)rá   r¶   rä   r1   Úfunction_or_memberræ   rç   r   rè   ré   rê   rã   rí   rë   Úseen_import_errorry   Úglobal_watcherrP   rî   r{   s    rJ   rô   zErrors.initialize  s“   € Ø ˆÔÜ ›UˆÔØˆŒØ#' &ˆÔØˆÔØˆÔÜ"-Ñ.GÓ"HˆÔÜ ›UˆÔÜ"%£%ˆÔÜ›EˆÔØˆŒ
Ø!ˆÔØ!&ˆÔØˆŒØ#ˆÔÜ#¤DÓ)ˆ�rL   c                ó$   — | j                  «        y rx   )rô   r{   s    rJ   ÚresetzErrors.reset  s   € Ø�‰ÕrL   c                óº   — t         j                  j                  |«      }t         j                  j                  |«      dk7  r|t         j                  z  }|| _        y)z4Set path prefix that will be removed from all paths.r4   N)ÚosÚpathÚnormpathÚbasenameÚseprå   )rI   Úprefixs     rJ   Úset_ignore_prefixzErrors.set_ignore_prefix  sC   € ä—‘×!Ñ! &Ó)ˆä�7‰7×Ñ˜FÓ# rÒ)Ø”b—f‘fÑˆFØ#ˆÕrL   c                óÖ   — | j                   j                  rt        j                  j	                  |«      S t        j                  j                  |«      }t        || j                  «      S rx   )ró   Úshow_absolute_pathrý   rþ   Úabspathrÿ   Úremove_path_prefixrå   ©rI   rR   s     rJ   Úsimplify_pathzErrors.simplify_path  sI   € Ø�<‰<×*Ò*Ü—7‘7—?‘? 4Ó(Ð(ä—7‘7×#Ñ# DÓ)ˆDÜ% d¨D×,>Ñ,>Ó?Ð?rL   c                ó<   — || _         || _        || _        || _        y)z/Set the path and module id of the current file.N)rR   rë   rí   ró   )rI   rR   r8   ró   rí   s        rJ   Úset_filezErrors.set_file&  s!   € ð ˆŒ	Ø#ˆÔØˆŒ
Øˆ�rL   c                ó^   — || j                   |<   |r| j                  j                  |«       y y rx   )ræ   ré   r¹   )rI   rR   ræ   Ú
ignore_alls       rJ   Úset_file_ignored_lineszErrors.set_file_ignored_lines5  s0   € ð $1ˆ×Ñ˜4Ñ ÙØ×Ñ×"Ñ" 4Õ(ð rL   c                ó"   — || j                   |<   y rx   )rç   )rI   rR   rç   s      rJ   Úset_skipped_lineszErrors.set_skipped_lines<  s   € Ø#0ˆ×Ñ˜4Ò rL   c                óf   — | j                   �| j                   j                  «       S | j                  S )zxRetrieves the current target from the associated scope.

        If there is no associated scope, use the target module.)rí   Úcurrent_targetrë   r{   s    rJ   r  zErrors.current_target?  s-   € ð �:‰:Ð!Ø—:‘:×,Ñ,Ó.Ð.Ø×!Ñ!Ð!rL   c                ó   — | j                   S rx   )rë   r{   s    rJ   Úcurrent_modulezErrors.current_moduleG  s   € Ø×!Ñ!Ð!rL   c                ó6   — | j                   j                  «       S )z$Return a copy of the import context.)r1   Úcopyr{   s    rJ   Úimport_contextzErrors.import_contextJ  s   € à�‰×#Ñ#Ó%Ð%rL   c                ó.   — |j                  «       | _        y)z3Replace the entire import context with a new value.N)r  r1   )rI   Úctxs     rJ   Úset_import_contextzErrors.set_import_contextN  s   € àŸ(™(›*ˆ�rL   Úerrorr   )rG   rE   rH   r:   ÚoffsetrC   rD   r>   c               óæ  — | j                   rP| j                   j                  «       }| j                   j                  dkD  rd}| j                   j                  «       }nd}d}|
�|
|k  r|}
|€d}|€|dk(  rd}n|dz   }||
k(  r
||k  r|dz   }|	rd|	z  |z   }|xs |r|j                  nd}|�"||j                  k(  sJ d«       ‚|dk(  sJ d«       ‚|xs |st
        j                  nd}t        | j                  «       ||f|||
|||||||| j                  «       | j                  «       |¬	«      }| j                  r(| j                  | j                     j                  |«       | j                  |«       |S )
aN  Report message at the given line using the current error context.

        Args:
            line: line number of error
            column: column number of error
            message: message to report
            code: error code (defaults to 'misc'; not shown for notes)
            blocker: if True, don't continue analysis after this error
            severity: 'error' or 'note'
            only_once: if True, only report this exact message once per build
            origin_span: lines where `type: ignore`s have effect for this error
                (default is [line])
            offset: number of spaces to prefix this message
            end_line: if known, end line of error location
            end_column: if known, end column of error location
            parent_error: an error this note is attached to (for notes only).
        r   NrØ   rµ   ú z#Must have same error code as parentr@   z!Only notes can have parent errors)r1   r3   rA   rB   rC   rD   rE   rF   r6   rG   rH   r:   r8   r9   r>   )rí   Úcurrent_type_nameÚignoredÚcurrent_function_namer6   r…   ÚMISCr/   r  r  r  rù   rî   rR   rz   Úadd_error_info)rI   rA   rB   rF   r6   rG   rE   rH   r:   r  rC   rD   r>   rS   rT   rŠ   s                   rJ   ÚreportzErrors.reportR  sœ  € ðB �:Š:Ø—:‘:×/Ñ/Ó1ˆDØ�z‰z×!Ñ! AÒ%Ø�Ø—z‘z×7Ñ7Ó9‰HàˆDØˆHð Ð˜x¨$šØˆHàˆ>ØˆFØÐØ˜Š|Ø‘
à# a™Z�
Ø�8Ò 
¨fÒ 4à !™ˆJáØ˜F‘l WÑ,ˆGàÒD©\˜×)Ò)¸tˆØÐ#Ø˜<×,Ñ,Ò,ÐSÐ.SÓSÐ,Ø˜vÒ%ÐJÐ'JÓJÐ%ØÒ<©'œŸ
š
°tˆäØ×*Ñ*Ó,Ø˜XÐ&ØØØØ!ØØØØØØ#Ø×&Ñ&Ó(Ø×&Ñ&Ó(Ø%ô
ˆð" ×ÒØ�M‰M˜$Ÿ)™)Ñ$×+Ñ+¨DÔ1Ø×Ñ˜DÔ!ØˆrL   c                óX  — || j                   vsJ ‚| j                  ||«      ry || j                  vrg | j                  |<   | j                  |   j                  |«       |j                  r| j
                  j                  |«       |j                  t        t        t        fv rd| _        y y )NT)rä   Ú_filter_errorrá   rz   rG   rã   r¹   r6   r   r    r   rø   ©rI   rR   rŠ   s      rJ   Ú_add_error_infozErrors._add_error_info«  sŸ   € Ø˜4×-Ñ-Ñ-Ð-Ð-ð ×Ñ˜d DÔ)ØØ�t×*Ñ*Ñ*Ø(*ˆD×Ñ Ñ%Ø×Ñ˜DÑ!×(Ñ(¨Ô.Ø�<Š<Ø×Ñ×!Ñ! $Ô'Ø�9‰9œ¤Ô1AÐBÑBØ%)ˆDÕ"ð CrL   ©rH   r<   c               ó  — t        |j                  |j                  |j                  |j                  |j
                  |j                  d||d||j                  |j                  |j                  |¬«      }| j                  ||«       y)z�Generate an additional note for an existing ErrorInfo.

        This skip the logic in add_error_info() and goes to _add_error_info().
        r@   FrW   N)r/   r1   r3   rA   rB   rC   rD   r8   r9   r:   r(  )rI   rR   rŠ   rF   r6   rH   r<   s          rJ   Únote_for_infozErrors.note_for_info¹  ss   € ô Ø—‘Ø—n‘nØ—‘Ø—;‘;Ø—]‘]Ø—‘ØØØØØØ—;‘;Ø—;‘;Ø×(Ñ(Øô
ˆð" 	×Ñ˜T 4Õ(rL   c                ó¤   — t        | j                  «       d|d|dd||dd| j                  «       | j                  ¬«      }| j	                  ||«       y)z}Generate a simple error in a module.

        This skip the logic in add_error_info() and goes to _add_error_info().
        ©NNrØ   r  F)r1   r3   rA   rB   rC   rD   rE   rF   r6   rG   rH   r8   r9   N)r/   r  r  rë   r(  )rI   rR   rA   rF   r6   rŠ   s         rJ   Úreport_simple_errorzErrors.report_simple_errorÚ  s_   € ô Ø×*Ñ*Ó,Ø"ØØØØØØØØØØ×&Ñ&Ó(à×%Ñ%ô
ˆð  	×Ñ˜T 4Õ(rL   c              #  óz   K  — t        | j                  «      }|dkD  r|dz  }| j                  |   –— |dkD  rŒyy­w)z2Yield the `ErrorWatcher` stack from top to bottom.r   rµ   N)rO   ry   )rI   Úis     rJ   Úget_watcherszErrors.get_watchersó  s<   è ø€ ä�—‘ÓˆØ�!ŠeØ�‰FˆAØ—.‘. Ñ#Ò#ð �!�eùs   ‚6;¹;c                óL   ‡‡— t        ˆˆfd„| j                  «       D «       «      S )zy
        process ErrorWatcher stack from top to bottom,
        stopping early if error needs to be filtered out
        c              3  óB   •K  — | ]  }|j                  ‰‰«      –— Œ y ­wrx   )rŒ   )r­   ÚwrR   rŠ   s     €€rJ   r°   z'Errors._filter_error.<locals>.<genexpr>ÿ  s   øè ø€ ÒG¨a�1—:‘:˜d D×)ÑGùs   ƒ)Úanyr1  r'  s    ``rJ   r&  zErrors._filter_errorú  s   ù€ ô
 ÔG°4×3DÑ3DÓ3FÔGÓGÐGrL   ©rR   c               ót  — |j                   }|xs | j                  }| j                  ||«      ry |j                  s¢|| j                  v r…|D ]€  }| j                  ||| j                  |   «      sŒ$|j                  xs t        j                  }| j                  |«      s y | j                  |   |   j                  |j                  «        y  || j                  v ry |j                  r>|j                  | j                  v ry | j                  j!                  |j                  «       | j"                  rF|j                  t$        t&        t(        fvr)| j+                  «       rd|_        | j/                  ||«       | j1                  ||«       | j                  j3                  |i «      j3                  |j4                  g «      }|rž|j                  r’d|j                  j                  › ddj7                  |«      › d�}|j                  t8        v r>t8        |j                     j                  }||v rd|j                  j                  › d�dz   }| j;                  |||d d	¬
«       | j<                  j>                  rÁ| j<                  j@                  sª|j                  ��|j                  tB        vrŠ|j                  j                  tD        v rmdtF        › d|j                  j                  › d�}	|	| j                  v ry | j                  j!                  |	«       | j;                  |||	|j                  dd¬«       y y y y y y )NTzError code "z" not covered by "type: ignore[ú, z
]" commentzError code changed to z; "type: ignore" comment zmay be out of dateF©rH   zSee ú-z for more infoé   r)  )$r:   rR   r&  rG   ræ   Úis_ignored_errorr6   r…   r"  Úis_error_code_enabledrè   rz   ré   rH   rF   rê   r¹   rø   r   r    r   Úhas_many_errorsrg   Úreport_hidden_errorsr(  ÚgetrA   Újoinr-   r+  ró   Úshow_error_code_linksrð   r+   r"   r,   )
rI   rŠ   rR   r®   Ú
scope_lineÚerr_codeÚignored_codesÚmsgÚold_coderF   s
             rJ   r#  zErrors.add_error_info  sÝ  € Ø× Ñ ˆØÒ �t—y‘yˆð
 ×Ñ˜d DÔ)ØØ�|Š|Ø�t×)Ñ)Ñ)ð #(ò 	�JØ×,Ñ,¨Z¸¸t×?QÑ?QÐRVÑ?WÕXØ#'§9¡9Ò#:´·
±
˜Ø#×9Ñ9¸(ÔCñ #à×/Ñ/°Ñ5°jÑA×HÑHÈÏÉÔWÙð	ð �t×)Ñ)Ñ)ØØ�>Š>Ø�|‰|˜t×6Ñ6Ñ6ØØ×#Ñ#×'Ñ'¨¯©Ô5à×"Ò"Ø—	‘	¤&¬.Ô:JÐ!KÑKØ×$Ñ$Ô&ð ˆDŒKØ×%Ñ% d¨DÔ1Ø×Ñ˜T 4Ô(Ø×*Ñ*×.Ñ.¨t°RÓ8×<Ñ<¸T¿Y¹YÈÓKˆÙ˜TŸYšYð # 4§9¡9§>¡>Ð"2Ð2QÐRV×R[ÑR[Ð\iÓRjÐQkÐkuÐxˆCØ�y‰yÔ0Ñ0ô 0°·	±	Ñ:×?Ñ?�Ø˜}Ñ,à0°·±·±Ð0@Ð@YÐZØ.ñ/ð ð ×Ñ˜t T¨3°ÀÐÔFà�L‰L×.Ò.Ø—L‘L×1Ò1Ø—	‘	Ð%Ø—	‘	¤Ñ0Ø—	‘	—‘Ô"2Ñ2àœ\˜N¨!¨D¯I©I¯N©NÐ+;¸>ÐJˆGØ˜$×1Ñ1Ñ1ØØ×#Ñ#×'Ñ'¨Ô0Ø×Ñ˜t T¨7°D·I±IÈÐXZÐÕ[ð 3ð 1ð &ð 2ð /rL   c                ó  — | j                   j                  dk  ryt        | j                  «      | j                   j                  k\  ryt	        d„ | j                  j                  «       D «       «      | j                   j                  k\  ryy)Nr   FTc              3  ó2   K  — | ]  }t        |«      –— Œ y ­wrx   ©rO   )r­   rr   s     rJ   r°   z)Errors.has_many_errors.<locals>.<genexpr>M  s   è ø€ ÒG ”�F—ÑGùó   ‚)ró   Úmany_errors_thresholdrO   rá   ÚsumÚvaluesr{   s    rJ   r>  zErrors.has_many_errorsG  sn   € Ø�<‰<×-Ñ-°Ò1ØÜˆt×"Ñ"Ó# t§|¡|×'IÑ'IÒIØäÑG¨$×*=Ñ*=×*DÑ*DÓ*FÔGÓGØ�|‰|×1Ñ1ò2ð ØrL   c                óˆ   — d}|| j                   v ry | j                   j                  |«       | j                  |||d d¬«       y )Nz\(Skipping most remaining errors due to unresolved imports or missing stubs; fix these first)Tr9  )rê   r¹   r+  )rI   rR   rŠ   rF   s       rJ   r?  zErrors.report_hidden_errorsS  sL   € ð!ð 	ð �d×-Ñ-Ñ-ØØ×Ñ×#Ñ# GÔ,Ø×Ñ˜4  w°ÀÐÕErL   c                óŠ  — |j                   ry|j                  r| j                  |j                  «      sy||vry||   sy|j                  rw| j                  |j                  «      r\|j                  j                  ||   v xs? |j                  j                  d uxr% |j                  j                  j                  ||   v S y©NFT)rG   r6   r=  Úsub_code_of)rI   rA   rŠ   Úignoress       rJ   r<  zErrors.is_ignored_error]  s¬   € Ø�<Š<àØ�9Š9˜T×7Ñ7¸¿	¹	ÔBØØ�wÑØØ�tŠ}àØ�9Š9˜×3Ñ3°D·I±IÔ>à—	‘	—‘ '¨$¡-Ð/ò @Ø—9‘9×(Ñ(°Ð4ò @Ø—I‘I×)Ñ)×.Ñ.°'¸$±-Ð?ðð
 rL   c                ó¼   — | j                   j                  }| j                   j                  }||v ry||v ry|j                  �|j                  |v ry|j                  S rQ  )ró   Údisabled_error_codesÚenabled_error_codesrR  Údefault_enabled)rI   Ú
error_codeÚcurrent_mod_disabledÚcurrent_mod_enableds       rJ   r=  zErrors.is_error_code_enabledp  sc   € Ø#Ÿ|™|×@Ñ@ÐØ"Ÿl™l×>Ñ>ÐàÐ-Ñ-ØØÐ.Ñ.ØØ×#Ñ#Ð/°J×4JÑ4JÐNbÑ4bØà×-Ñ-Ð-rL   c                óŒ  — || j                   v r¶g }d}| j                   |   D ]c  }|j                  |vr!|j                  |«       ||j                  z  }Œ2|j                  sŒ?| j
                  j                  |j                  «       Œe || j                   |<   |s+|| j                  v r| j                  j                  |«       yyyy)z=Remove errors in specific fine-grained targets within a file.FN)	rá   r9   rz   rG   rH   rê   ÚremoverF   rã   )rI   rþ   ÚtargetsÚ
new_errorsÚhas_blockerrŠ   s         rJ   Úclear_errors_in_targetszErrors.clear_errors_in_targets}  s¿   € à�4×&Ñ&Ñ&ØˆJØˆKØ×+Ñ+¨DÑ1ò A�Ø—;‘; gÑ-Ø×%Ñ% dÔ+Ø 4§<¡<Ñ/‘KØ—^“^Ø×+Ñ+×2Ñ2°4·<±<Õ@ðAð )3ˆD×Ñ Ñ%Ù 4¨4×+<Ñ+<Ñ#<Ø×!Ñ!×(Ñ(¨Õ.ð $=�;ð 'rL   c                óz  — |s|| j                   v ry | j                  |   }| j                  |   }|j                  «       D ]ô  \  }}|| j                  |   v rŒt
        j                  j                  |v rŒ5t        ||   «      }|D �cg c]	  }||vsŒ|‘Œ }	}|s|rŒ\|r|	sŒad}
t        |«      dkD  r|	rddj                  |	«      › d�}
d|
› d�}|	D ]?  }t        |«      t
        j                  |   z  }|sŒ%|ddj                  |«      › d	|› d
�z  }ŒA | j                  |||t
        j                  ¬«       Œö y c c}w )Nr4   rµ   ú[r8  ú]zUnused "type: ignorez	" commentz, use narrower [z] instead of [z] code©r6   )ré   ræ   rè   rÄ   rç   r…   ÚUNUSED_IGNOREr6   r¶   rO   rA  Úsub_code_mapr.  )rI   rR   Úis_typeshedræ   rè   rA   rE  Úused_ignored_codesÚcÚunused_ignored_codesÚunused_codes_messagerF   ÚunusedÚnarrowers                 rJ   Úgenerate_unused_ignore_errorsz$Errors.generate_unused_ignore_errorsŒ  s|  € Ù˜$ $×"4Ñ"4Ñ4ØØ×*Ñ*¨4Ñ0ˆØ!×4Ñ4°TÑ:ÐØ#0×#6Ñ#6Ó#8ò 	TÑˆD�-Ø�t×)Ñ)¨$Ñ/Ñ/ØÜ×"Ñ"×'Ñ'¨=Ñ8ØÜ!$Ð%7¸Ñ%=Ó!>ÐØ/<Ö#\¨!ÀÐI[Ò@[¢AÐ#\Ð Ð#\á Ñ%7ØáÑ%9Øà#%Ð Ü�=Ó! AÒ%Ñ*>Ø)*¨4¯9©9Ð5IÓ+JÐ*KÈ1Ð'MÐ$Ø,Ð-AÐ,BÀ)ÐLˆGØ.ò d�ÜÐ1Ó2´U×5GÑ5GÈÑ5OÑO�ÚØÐ!1°$·)±)¸HÓ2EÐ1FÀnÐU[ÐT\Ð\bÐcÑc‘Gðdð
 ×$Ñ$ T¨4°¼u×?RÑ?RÐ$ÕSñ/	Tùò $]s   Â	D8ÂD8c                óx  — |s|| j                   v ry | j                  |   }| j                  |   j                  «       D ]z  \  }}|| j                  |   v rŒ|rŒ|r||   sŒ#d}t        t        ||   «      «      }|rddj                  |«      › d�}d|› �}| j                  |||t        j                  ¬«       Œ| y )Nr4   z (consider "type: ignore[r8  z]" instead)z)"type: ignore" comment without error coderd  )ré   rè   ræ   rÄ   rç   Úsortedr¶   rA  r.  r…   ÚIGNORE_WITHOUT_CODE)	rI   rR   Úis_warning_unused_ignoresrg  rè   rA   rE  Ú
codes_hintrF   s	            rJ   Ú#generate_ignore_without_code_errorsz*Errors.generate_ignore_without_code_errorsª  sÝ   € ñ ˜$ $×"4Ñ"4Ñ4Øà!×4Ñ4°TÑ:ÐØ#'×#5Ñ#5°dÑ#;×#AÑ#AÓ#Cò 	ZÑˆD�-Ø�t×)Ñ)¨$Ñ/Ñ/ØÙØñ )Ð1CÀDÒ1IØàˆJÜ"¤3Ð'9¸$Ñ'?Ó#@ÓAˆMÙØ8¸¿¹À=Ó9QÐ8RÐR]Ð^�
àAÀ*ÀÐNˆGà×$Ñ$ T¨4°¼u×?XÑ?XÐ$ÕYñ%	ZrL   c                óV   — t        d„ | j                  j                  «       D «       «      S )z(Return the number of generated messages.c              3  ó2   K  — | ]  }t        |«      –— Œ y ­wrx   rJ  )r­   Úxs     rJ   r°   z&Errors.num_messages.<locals>.<genexpr>Ç  s   è ø€ Ò@˜a”3�q—6Ñ@ùrK  )rM  rá   rN  r{   s    rJ   Únum_messageszErrors.num_messagesÅ  s"   € äÑ@ 4×#6Ñ#6×#=Ñ#=Ó#?Ô@Ó@Ð@rL   c                ó,   — t        | j                  «      S )z!Are there any generated messages?)r^   rá   r{   s    rJ   Ú	is_errorszErrors.is_errorsÉ  s   € ä�D×'Ñ'Ó(Ð(rL   c                ó,   — t        | j                  «      S )z%Are the any errors that are blockers?)r^   rã   r{   s    rJ   Úis_blockerszErrors.is_blockersÍ  s   € ä�D×%Ñ%Ó&Ð&rL   c                ó†   — | j                   D ]2  }| j                  |   D ]  }|j                  sŒ|j                  c c S  Œ4 y)zAReturn the module with a blocking error, or None if not possible.N)rã   rá   rG   r8   )rI   rþ   Úerrs      rJ   Úblocker_modulezErrors.blocker_moduleÑ  sG   € à×%Ñ%ò 	&ˆDØ×*Ñ*¨4Ñ0ò &�Ø—;“;ØŸ:™:Ô%ñ&ð	&ð rL   c                ó>   — || j                   v xr || j                  vS )z(Are there any errors for the given file?)rá   ré   r  s     rJ   Úis_errors_for_filezErrors.is_errors_for_fileÙ  s#   € à�t×*Ñ*Ð*ÒM¨t¸4×;MÑ;MÐ/MÐMrL   c                óÐ   — | j                   | j                  v ry| j                  j                  ry| j                  r*| j                  d   }|j
                  du r|j                  €yy)a7  Should we generate simple/fast error messages?

        Return True if errors are not shown to user, i.e. errors are ignored
        or they are collected for internal use only.

        If True, we should prefer to generate a simple message quickly.
        All normal errors should still be reported.
        TrØ   F)rR   ré   ró   Úignore_errorsry   rt   rv   )rI   Ú_watchers     rJ   Úprefer_simple_messageszErrors.prefer_simple_messagesÝ  s]   € ð �9‰9˜×*Ñ*Ñ*àØ�<‰<×%Ò%ØØ�>Š>Ø—~‘~ bÑ)ˆHØ×Ñ 4Ñ'¨H×,>Ñ,>Ð,FàØrL   c                óV   — t        | j                  «       || j                  «       ¬«      ‚)zpRaise a CompileError with the generated messages.

        Render the messages suitable for displaying.
        )Ú
use_stdoutÚmodule_with_blocker)ÚCompileErrorÚnew_messagesr  )rI   r‡  s     rJ   Úraise_errorzErrors.raise_errorò  s*   € ô Ø×ÑÓ¨JÈD×L_ÑL_ÓLaô
ð 	
rL   c           	     ó¬  — g }|D �]Ë  \  }}}}}}	}
}d}|�s| j                   j                  rC|dk\  r>|dk\  r9|› d|› dd|z   › �}| j                   j                  r%|dk\  r |dk\  r|d|› d|› �z  }n|dk\  r|› d|› �}n|}|› d|	› d|
› �}n|
}| j                  s|r|	dk7  s|t        v r|› d|› d	�}|j                  |«       | j                   j                  sŒÑ|	d
k(  sŒ×|sŒÚ|dkD  sŒà||dz
     }|j                  «       }t        |«      t        |j                  «       «      z
  }||k  r|}t        |d| j                  «       «      }t        |d| j                  «       «      }|j                  dt        z  |z   «       d}||k(  r||kD  rdd||z
  dz
  z  › �}n||k7  rddt        |«      |z
  dz
  z  › �}|j                  dt        |z   z  |z   «       �ŒÎ |S )zîReturn a string list that represents the error messages.

        Use a form suitable for displaying to the user. If self.pretty
        is True also append a relevant trimmed source code line (only for
        severity 'error').
        r4   Nr   ú:rµ   ú: r@   z  [rc  r  r  ú^ú~)ró   Úshow_column_numbersÚshow_error_endrð   r*   rz   ÚprettyÚ
expandtabsrO   Úlstripr'   )rI   Úerror_tuplesÚsource_linesÚarR   rA   rB   rC   rD   rE   rF   r6   ÚsÚsrclocÚsource_lineÚsource_line_expandedÚ
min_columnÚmarkers                     rJ   Úformat_messages_defaultzErrors.format_messages_defaultý  s@  € ð ˆØQ]ó .	NÑMˆD�$˜ ¨*°hÀÈØˆAØÐØ—<‘<×3Ò3¸Àº	ÀfÐPQÂkØ $˜v Q t f¨A¨a°&©j¨\Ð:�FØ—|‘|×2Ò2°xÀ1²}ÈÐWXÊØ A h Z¨q°°Ð"=Ñ=™Ø˜Q’YØ $˜v Q t fÐ-‘Fà!�FØ�h˜b  
¨"¨W¨IÐ6‘à�à×)Ò)ÙØ Ò'¨4´?Ñ+Bð �c˜˜T˜F !Ð$�Ø�H‰H�QŒKØ�|‰|×"Ó"à˜wÓ&ª<¸DÀ1»HØ".¨t°a©xÑ"8�KØ+6×+AÑ+AÓ+CÐ(Ü!$ [Ó!1´C¸×8JÑ8JÓ8LÓ4MÑ!M�JØ 
Ò*à!+˜ô ! ¨W¨fÐ!5×!@Ñ!@Ó!BÓC�FÜ!$ [°°*Ð%=×%HÑ%HÓ%JÓ!K�Jð —H‘H˜SÔ#8Ñ8Ð;OÑOÔPØ �FØ 4Ò'¨J¸Ò,?Ø#$ S¨J¸Ñ,?À!Ñ,CÑ%DÐ$EÐ!F™Ø! TÒ)à#$ S¬CÐ0DÓ,EÈÑ,NÐQRÑ,RÑ%SÐ$TÐ!U˜Ø—H‘H˜SÔ$9¸FÑ$BÑCÀfÑLÖMð].	Nð^ ˆrL   c                óæ   — || j                   vrg S | j                   |   }|D �cg c]  }|j                  rŒ|‘Œ }}| j                  | j                  |«      «      }| j	                  ||«      S c c}w )zCReturn an error tuple list of new error messages from a given file.)rá   rg   Úremove_duplicatesÚsort_messagesÚrender_messages)rI   rþ   r»   rŠ   s       rJ   Úfile_messageszErrors.file_messages8  sr   € à�t×*Ñ*Ñ*ØˆIà×(Ñ(¨Ñ.ˆ
Ø'1ÖE˜t¸¿»’dÐEˆ
ÐEØ×+Ñ+¨D×,>Ñ,>¸zÓ,JÓKˆ
Ø×#Ñ# D¨*Ó5Ð5ùò Fs
   ¤A.¶A.c                ór  — | j                   j                  |«       |�*t        |«      }|D �cg c]  }|j                  |«      ‘Œ c}S d}| j                  j
                  rB| j                  r6| j                  |«      }|r| j                  |«      }n| j                  |«      }| j                  ||«      S c c}w )zReturn a string list of new error messages from a given file.

        Use a form suitable for displaying to the user.
        N)	rä   r¹   Úcreate_errorsÚreport_errorró   r“  rï   Úfind_shadow_file_mappingrŸ  )rI   rþ   r–  Ú	formatterrr   r~  r—  Úmapped_paths           rJ   Úformat_messageszErrors.format_messagesB  s¬   € ð 	×Ñ×Ñ˜tÔ$ØÐ Ü" <Ó0ˆFØ;AÖB°C�I×*Ñ*¨3Õ/ÒBÐBàˆØ�<‰<×Ò 4×#3Ò#3ð ×7Ñ7¸Ó=ˆKÙØ#×/Ñ/°Ó<‘à#×/Ñ/°Ó5�Ø×+Ñ+¨L¸,ÓGÐGùò Cs   ­B4c                ó†   — | j                   j                  €y| j                   j                  D ]  }|d   |k(  sŒ|d   c S  y)zAReturn the shadow file path for a given source file path or None.Nr   rµ   )ró   Úshadow_file)rI   rþ   r0  s      rJ   r¨  zErrors.find_shadow_file_mappingY  sG   € à�<‰<×#Ñ#Ð+Øà—‘×)Ñ)ò 	ˆAØ�‰t�t‹|Ø˜‘t’ð	ð rL   c                óâ   — g }| j                   j                  «       D ]O  }|| j                  vsŒ| j                  |«      }|j	                  | j                  ||| j                  ¬«      «       ŒQ |S )zàReturn a string list of new error messages.

        Use a form suitable for displaying to the user.
        Errors from different files are ordered based on the order in which
        they first generated an error.
        )r©  )rá   Úkeysrä   r¤  Úextendr«  rñ   )rI   Úmsgsrþ   r–  s       rJ   rŠ  zErrors.new_messagesc  ss   € ð ˆØ×'Ñ'×,Ñ,Ó.ò 	ˆDØ˜4×-Ñ-Ò-Ø#×1Ñ1°$Ó7�Ø—‘Ø×(Ñ(¨¨|Àt×G[ÑG[Ð(Ó\õð	ð ˆrL   c                óž   — | j                   j                  «       D ��ch c]"  }|D ]  }|j                  sŒ|j                  ’Œ Œ$ c}}S c c}}w )z0Return a set of all targets that contain errors.)rá   rN  r9   )rI   ÚerrsrŠ   s      rJ   r]  zErrors.targetss  sO   € ð
 %)×$7Ñ$7×$>Ñ$>Ó$@÷
Ø ÈTò
ØEIÐUY×U`ÓU`ˆD�K‹Kð
Øó
ð 	
ùó 
s
   žA	µA	c                óŽ  — | j                  |«      }g }g }d}d}|D �]%  }| j                  j                  sn£|j                  |k7  r”t	        |j                  «      dz
  }|}	|	dk\  ru|j                  |	   \  }
}d}|	|k  rd}|	dkD  r|dz  }n|dz  }t        |
| j                  «      }
|j                  dddddd	|j                  |
|«      df«       |	dz  }	|	dk\  rŒu|j                  \  }}| j                  j                  sn¹||k7  s||k7  rq|€:|€|j                  |ddddd	d
df«       n‘|j                  |ddddd	d|› d�df«       ns|€d|› d�}ndj                  ||«      }|j                  |ddddd	|df«       n>||k7  r9|€|j                  |ddddd	d
df«       n|j                  |ddddd	d|› d�df«       |j                  �|j                  j                  nd}|j                  ||j                  |j                  |j                  |j                  |j                  |j                   |f«       |j                  }|}|}�Œ( |S )aE  Translate the messages into a sequence of tuples.

        Each tuple is of form (path, line, col, severity, message, code).
        The rendered sequence includes information about error contexts.
        The path item may be None. If the line item is negative, the
        line number is not defined for the tuple.
        Nrµ   r   z${}:{}: note: In module imported herez{}:{}: note: ... from hereú,r�  rØ   r@   zAt top level:z
In class "z":zIn function "zIn member "{}" of class "{}":)r	  ró   Úshow_error_contextr1   rO   r  rå   rz   Úformatr3   r6   rA   rB   rC   rD   rE   rF   )rI   rR   rr   ÚresultÚprev_import_contextÚprev_functionÚ	prev_typeÚer‚   r0  rþ   rA   ÚfmtrS   rT   rF  r6   s                    rJ   r£  zErrors.render_messages{  s‡  € ð ×!Ñ! $Ó'ˆØ#%ˆØ57ÐØ$(ˆØ $ˆ	àó 5	ˆAà—<‘<×2Ò2ØØ—‘Ð!4Ò4Ü˜1Ÿ<™<Ó(¨1Ñ,�Ø�Ø˜1’fØ!"§¡¨a¡‘J�D˜$Ø@�CØ˜4’xØ:˜Ø˜1’uØ˜s™
™à˜s™
˜ô .¨d°D×4FÑ4FÓG�DØ—M‘M 4¨¨R°°R¸ÀÇÁÈDÐRVÓAWÐY]Ð"^Ô_Ø˜‘F�Að ˜1“fð  Ÿ[™[‰NˆD�(Ø—<‘<×2Ò2ØØ˜]Ò*¨d°iÒ.?ØÐ#Ø�|ØŸ™ t¨R°°R¸¸VÀ_ÐVZÐ&[Õ\àŸ™ t¨R°°R¸¸VÀzÐRVÐQWÐWYÐEZÐ\`Ð&aÕbð �|Ø -¨h¨Z°rÐ:™à=×DÑDÀXÈtÓT˜Ø—M‘M 4¨¨R°°R¸ÀÀdÐ"KÕLà˜Ò"Ø�<Ø—M‘M 4¨¨R°°R¸ÀÐRVÐ"WÕXà—M‘M 4¨¨R°°R¸À:ÈdÈVÐSUÐAVÐX\Ð"]Ô^à"#§&¡&Ð"4�1—6‘6—;’;¸$ˆDØ�M‰MØ�q—v‘v˜qŸx™x¨¯©°Q·\±\À1Ç:Á:ÈqÏyÉyÐZ^Ð_ôð #$§,¡,ÐØ$ˆMØŠIðk5	ðn ˆrL   c                ó”  — g }d}|t        |«      k  rµ|}|dz   t        |«      k  r[||dz      j                  ||   j                  k(  r9|dz  }|dz   t        |«      k  r#||dz      j                  ||   j                  k(  rŒ9|dz  }t        ||| d„ ¬«      }| j                  |«      }|j	                  |«       |t        |«      k  rŒµ|S )zãSort an array of error messages locally by line number.

        I.e., sort a run of consecutive messages with the same
        context by line number, but otherwise retain the general
        ordering of the messages.
        r   rµ   c                ó2   — | j                   | j                  fS rx   r²   ©rw  s    rJ   rÂ   z&Errors.sort_messages.<locals>.<lambda>Ó  s   € °A·F±F¸A¿H¹HÐ3E€ rL   ©Úkey)rO   r1   rp  Úsort_within_contextr°  ©rI   rr   r¸  r0  Úi0r˜  s         rJ   r¢  zErrors.sort_messagesÂ  sÕ   € ð #%ˆØˆØ”#�f“+ŠoØˆBà�a‘%œ#˜f›+Ò%¨&°°Q±©-×*BÑ*BÀfÈQÁi×FZÑFZÒ*ZØ�Q‘�ð �a‘%œ#˜f›+Ò%¨&°°Q±©-×*BÑ*BÀfÈQÁi×FZÑFZÓ*Zà�‰FˆAô �v˜b �|Ñ)EÔFˆAØ×(Ñ(¨Ó+ˆAØ�M‰M˜!Ôð ”#�f“+‹oð ˆrL   c                óž  — g }d}|t        |«      k  �r¹|}|dz   t        |«      k  �rn||dz      j                  ||   j                  k(  �rK||dz      j                  ||   j                  k(  �r(||dz      j                  ||   j                  k(  �r||dz      j                  ||   j                  k(  rã||dz      j
                  ||   j
                  k(  rÁ|dz  }|dz   t        |«      k  r«||dz      j                  ||   j                  k(  r‰||dz      j                  ||   j                  k(  rg||dz      j                  ||   j                  k(  rE||dz      j                  ||   j                  k(  r#||dz      j
                  ||   j
                  k(  rŒÁ|dz  }t        ||| d„ ¬«      }|j                  |«       |t        |«      k  r�Œ¹|S )zÁFor the same location decide which messages to show first/last.

        Currently, we only compare within the same error code, to decide the
        order of various additional notes.
        r   rµ   c                ó   — | j                   S rx   )r<   rÀ  s    rJ   rÂ   z,Errors.sort_within_context.<locals>.<lambda>ï  s
   € °1·:±:€ rL   rÁ  )rO   rA   rB   rC   rD   r6   rp  r°  rÄ  s         rJ   rÃ  zErrors.sort_within_contextØ  sÃ  € ð ˆØˆØ”#�f“+‹oØˆBð �A‘œ˜F›Ó#Ø˜1˜q™5‘M×&Ñ&¨&°©)¯.©.Ó8Ø˜1˜q™5‘M×(Ñ(¨F°1©I×,<Ñ,<Ó<Ø˜1˜q™5‘M×*Ñ*¨f°Q©i×.@Ñ.@Ó@Ø˜1˜q™5‘M×,Ñ,°°q±	×0DÑ0DÒDØ˜1˜q™5‘M×&Ñ&¨&°©)¯.©.Ò8à�Q‘�ð �A‘œ˜F›Ò#Ø˜1˜q™5‘M×&Ñ&¨&°©)¯.©.Ò8Ø˜1˜q™5‘M×(Ñ(¨F°1©I×,<Ñ,<Ò<Ø˜1˜q™5‘M×*Ñ*¨f°Q©i×.@Ñ.@Ò@Ø˜1˜q™5‘M×,Ñ,°°q±	×0DÑ0DÒDØ˜1˜q™5‘M×&Ñ&¨&°©)¯.©.Ó8ð �‰FˆAô �v˜b �|Ñ)=Ô>ˆAØ�M‰M˜!Ôð! ”#�f“+Œoð" ˆrL   c                óÜ  — g }t        t        «      }t        «       }|D ]ž  }|j                  �|j                  |«       Œ!|j                  |j
                  f||j                     vrF|j                  |«       ||j                     j                  |j                  |j
                  f«       ŒŽ|j                  |«       Œ  |D �cg c]  }|j                  �|j                  |vr|‘Œ  c}S c c}w rx   )r   r¶   r>   rz   rE   rF   rA   r¹   )rI   rr   r�   Úseen_by_lineÚremovedr~  s         rJ   r¡  zErrors.remove_duplicatesó  sØ   € ØˆÜ?JÌ3Ó?OˆÜ“%ˆØò 	!ˆCØ×ÑÐ+à×&Ñ& sÕ+Ø—,‘, §¡Ð,°LÀÇÁÑ4JÑJØ×&Ñ& sÔ+Ø˜SŸX™XÑ&×*Ñ*¨C¯L©L¸#¿+¹+Ð+FÕGà—‘˜CÕ ð	!ð 'ö
àØ×ÑÐ'¨3×+;Ñ+;À7Ñ+Jò ò
ð 	
ùò 
s   Ã#C))
ró   r$   rï   z(Callable[[str], list[str] | None] | Nonerð   zbool | Nonerñ   úErrorFormatter | Noner`   ra   rÏ   )r  r]   r`   ra   )rR   r]   r`   r]   rx   )
rR   r]   r8   r7   ró   r$   rí   rì   r`   ra   )F)rR   r]   ræ   údict[int, list[str]]r  r^   r`   ra   )rR   r]   rç   zset[int]r`   ra   )r`   r7   )r`   r0   )r  r0   r`   ra   )rA   r;   rB   r™   rF   r]   r6   r5   rG   r^   rE   r]   rH   r^   r:   r_   r  r;   rC   r™   rD   r™   r>   r=   r`   r/   )rR   r]   rŠ   r/   r`   ra   )rR   r]   rŠ   r/   rF   r]   r6   r5   rH   r^   r<   r;   r`   ra   )
rR   r]   rA   r;   rF   r]   r6   r5   r`   ra   )r`   zIterator[ErrorWatcher]r”   )rŠ   r/   rR   r7   r`   ra   r•   )rA   r;   rŠ   r/   rS  rÌ  r`   r^   )rX  r!   r`   r^   )rþ   r]   r]  râ   r`   ra   )rR   r]   rg  r^   r`   ra   )rR   r]   rr  r^   rg  r^   r`   ra   r¢   )rR   r]   r`   r^   )T)r‡  r^   r`   r   )r–  úlist[ErrorTuple]r—  zlist[str] | Noner`   ú	list[str])rþ   r]   r`   rÍ  )rþ   r]   r–  rÍ  r©  rË  r`   rÎ  )rþ   r]   r`   r7   )r`   rÎ  )r`   râ   )rR   r]   rr   r–   r`   rÍ  )rr   r–   r`   r–   )6rb   rc   rd   re   rf   rå   rR   rë   rí   rø   rù   rK   rô   rû   r  r	  r  r  r  r  r  r  r  r$  r(  r+  r.  r1  r&  r#  r>  r?  r<  r=  r`  rn  rt  rx  rz  r|  r  r�  r…  r‹  rŸ  r¤  r«  r¨  rŠ  r]  r£  r¢  rÃ  r¡  ri   rL   rJ   r‘   r‘   ´  s­  … ñð /Ó.ð Óð Óð &Ó%ð !%€M�:Ó$ð €Dˆ#ƒNð 3Ó2ð 'Ó&ð 8Ó7ð Óð !Ó ð
 !%€M�:Ó$Ø€Eˆ<Óð Ðð €NØ(Ó(à!Ó!ð AEØ(,Ø15ñàðð >ð	ð
 &ðð /ðð 
óó"*ó$ó$ó@ð VZðØðØ!+ðØ6=ðØFRðà	óð  RWð)Øð)Ø(<ð)ØJNð)à	ó)ó1ó"ó"ó&ó%ð "&ðWð ØØØ,0ØØ#Ø!%Ø)-ñWàðWð ðWð ð	Wð
 ðWð ðWð ðWð ðWð *ðWð ðWð ðWð ðWð 'ðWð 
óWór*ð*  Øñ)àð)ð ð)ð ð	)ð
 ð)ð ð)ð ð)ð 
ó)ðB)Øð)Ø"ð)Ø-0ð)Ø8Hð)à	ó)ó2$óHð EIõ D\óL
óFóó&.ó/ôTð> OTðZØðZØ48ðZØGKðZà	óZó6Aó)ó'óóNóô*	
ð9Ø,ð9Ø<Lð9à	ó9óv6ð ]aðHØðHØ'7ðHØDYðHà	óHó.óó 
óEóNó,ô6
rL   r‘   c                  óT   ‡ — e Zd ZU dZded<   dZdZded<   	 d		 	 	 	 	 	 	 d
ˆ fd„Zˆ xZS )r‰  aš  Exception raised when there is a compile error.

    It can be a parse, semantic analysis, type check or other
    compilation-related error.

    CompileErrors raised from an errors object carry all of the
    messages that have not been reported out by error streaming.
    This is patched up by build.build to contain either all error
    messages (if errors were streamed) or none (if they were not).

    rÎ  ÚmessagesFNr7   rˆ  c                ól   •— t         ‰| �  dj                  |«      «       || _        || _        || _        y )Nú
)rÕ   rK   rA  rÐ  r‡  rˆ  )rI   rÐ  r‡  rˆ  rÖ   s       €rJ   rK   zCompileError.__init__  s1   ø€ ô 	‰Ñ˜Ÿ™ 8Ó,Ô-Ø ˆŒØ$ˆŒØ#6ˆÕ rL   )FN)rÐ  rÎ  r‡  r^   rˆ  r7   r`   ra   )	rb   rc   rd   re   rf   r‡  rˆ  rK   rÞ   rß   s   @rJ   r‰  r‰    sQ   ø… ñ
ð ÓØ€Jà&*Ð˜Ó*ð `dð7Ø!ð7Ø/3ð7ØR\ð7à	÷7ñ 7rL   r‰  c                óH   — |�| j                  |«      r| t        |«      d S | S )z‡If path starts with prefix, return copy of path with the prefix removed.
    Otherwise, return path. If path is None, return None.
    N)Ú
startswithrO   )rþ   r  s     rJ   r  r  "  s+   € ð Ð˜dŸo™o¨fÔ5Ø”C˜“K�MÐ"Ð"àˆrL   c                óè  — |xs t         j                  }|xs t         j                  }|r"	 |j                  «       D ]  }t	        |«       Œ 	 |r|r	|› d|› d�}	n|› d�}	nd}	t	        |	› d�d|¬«       |j                  rt	        d	|¬«       nt	        d
|¬«       t	        dt        › �|¬«       |j                  r7t	        d|¬«       ddl	}
|
j                  t        j                  «       d   «       |j                  r| ‚|j                  s3|j                  s¤t	        dj                  |	«      |¬«       t)        d«      ‚t        j                  j!                  | «      }t        j"                  «       dd |j$                  dd t	        dj'                  |j                  «       «      |¬«       t	        |	› d�|¬«       t)        d«      ‚# t
        $ r"}t	        dt        |«      |¬«       Y d}~�ŒŸd}~ww xY w)zZReport internal error and exit.

    This optionally starts pdb or shows a traceback.
    zFailed to dump errors:r6  Nr�  rŽ  r4   zerror: INTERNAL ERROR --zPlease try using mypy master on GitHub:
https://mypy.readthedocs.io/en/stable/common_issues.html#using-a-development-mypy-buildz<Please report a bug at https://github.com/python/mypy/issueszfIf this issue continues with mypy master, please report a bug at https://github.com/python/mypy/issuesz	version: zDropping into pdbr   r¬   zM{}note: please use --show-traceback to print a traceback when reporting a bugéþÿÿÿz note: use --pdb to drop into pdb)ÚsysÚstdoutÚstderrrŠ  ÚprintÚ	ExceptionÚreprÚshow_tracebackÚmypy_versionÚpdbÚpost_mortemÚexc_infoÚraise_exceptionsr·  Ú	tracebackÚTracebackExceptionÚfrom_exceptionÚextract_stackÚstackrA  Ú
SystemExit)r~  rR   rA   rr   ró   rØ  rÙ  rF  r¼  r  rß  Útberrs               rJ   Úreport_internal_errorrê  ,  sØ  € ð Ò!”s—z‘z€FØÒ!”s—z‘z€Fñ ð	BØ×*Ñ*Ó,ò �Ü�c•
ññ ÙØ�v˜Q˜t˜f BÐ'‰Fà�v˜R�[‰Fàˆô 
Øˆ(Ð*Ð+ð	*ð õð ×ÒÜÐLÐSYÖZäðKàõ	
ô
 
ˆI”l�^Ð
$¨6Õ2ð ‡{‚{ÜÐ!¨Õ/Ûà�‰œŸ™› qÑ)Ô*ð ×ÒØˆ	Ø×!Ò!Ø�{Š{Üð'ß'-¡v¨f£~Øõô �Q‹-Ðô ×,Ñ,×;Ñ;¸CÓ@ˆÜ#×1Ñ1Ó3°C°RÐ8ˆ�‰�B�QˆÜˆb�g‰g�e—l‘l“nÓ%¨FÕ3Ü��Ð8Ð9ÀÕGô �Q‹-Ðøôo ò 	BÜÐ*¬D°«G¸&×AÓAûð	Bús   ¬ G Ç	G1ÇG,Ç,G1c                  ó8   — e Zd Z	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dd„Zy)Ú	MypyErrorc	                ó‚   — || _         || _        || _        || _        || _        || _        || _        || _        g | _        y rx   )	Ú	file_pathrA   rB   rC   rD   rF   Ú	errorcoderE   Úhints)	rI   rî  rA   rB   rC   rD   rF   rï  rE   s	            rJ   rK   zMypyError.__init__|  sC   € ð #ˆŒØˆŒ	ØˆŒØ ˆŒØ$ˆŒØˆŒØ"ˆŒØ ˆŒØ "ˆ�
rL   N)rî  r]   rA   r;   rB   r;   rC   r;   rD   r;   rF   r]   rï  r7   rE   zLiteral['error', 'note']r`   ra   )rb   rc   rd   rK   ri   rL   rJ   rì  rì  {  s_   „ ð#àð#ð ð#ð ð	#ð
 ð#ð ð#ð ð#ð ð#ð +ð#ð 
ô#rL   rì  c                ó\  — g }i }| D ]¢  }|\  }}}}}}	}
}|€Œ|	dv sJ ‚|	dk(  rY|||f}|j                  |«      }|€%t        ||||||
|d¬«      }|j                  |«       ŒY|j                  j                  |
«       Œut        ||||||
|d¬«      }|j                  |«       |||f}|||<   Œ¤ |S )N)r  r@   r@   )rE   r  )r@  rì  rz   rð  )r–  rr   Úlatest_error_at_locationÚerror_tuplerî  rA   rB   rC   rD   rE   rF   rï  Úerror_locationr  s                 rJ   r¦  r¦  –  s  € Ø €FØ@BÐà#ò  =ˆØVaÑSˆ	�4˜ ¨:°xÀÈ)ØÐØàÐ,Ñ,Ð,Ð,Ø�vÒØ'¨¨vÐ6ˆNØ,×0Ñ0°Ó@ˆEØˆ}ä!ØØØØØØØØ#ô	�ð —‘˜eÔ$Øà�K‰K×Ñ˜wÕ'ô Ø˜4 ¨°:¸wÈ	Ð\côˆEð �M‰M˜%Ô Ø'¨¨vÐ6ˆNØ7<Ð$ ^Ò4ðA =ðD €MrL   )rþ   r]   r  r7   r`   r]   r-  )r~  rÛ  rR   r7   rA   r;   rr   zErrors | Noneró   r$   rØ  úTextIO | NonerÙ  rõ  r`   r   )r–  rÍ  r`   zlist[MypyError])aÚ
__future__r   Úos.pathrý   r×  rã  Úcollectionsr   Úcollections.abcr   r   r   Ú	itertoolsr   Útypingr	   r
   r   r   r   Útyping_extensionsr   Úlibrt.internalr   r   r   r   rY   r   r   rN   Úmypyr   r…   Ú
mypy.cacher   r   r   r   r   r   r   Úmypy.error_formatterr   Úmypy.errorcodesr   r   r    r!   r"   Ú
mypy.nodesr#   Úmypy.optionsr$   Ú
mypy.scoper%   Ú
mypy.typesr&   Ú	mypy.utilr'   Úmypy.versionr(   rÞ  r)   ÚANNOTATION_UNCHECKEDr6   r†   r*   rf   r"  Ú
ASSIGNMENTÚARG_TYPEÚRETURN_VALUEÚATTR_DEFINEDÚNAME_DEFINEDÚOVERRIDEr+   r,   ÚLITERAL_REQÚTYPE_ABSTRACTr-   r/   rk   r˜   r¤   rÑ   r‘   rÛ  r‰  r  rê  rì  Útupler]   r;   Ú_ErrorLocationr¦  ri   rL   rJ   ú<module>r     sø  ðÞ "ã Û 
Û Ý #ß 8Ñ 8Ý ß <Õ <Ý "÷÷ õ %÷
÷ 
õ 
õ 0ß aÕ aÝ Ý  Ý Ý Ý +Ý 4áˆCƒL€ð  ×4Ñ4×9Ñ9¸5×;KÑ;K×;PÑ;PÐQ€�Ó Qð 
‡J�Jà	×ÑØ	‡N�NØ	×Ñà	×ÑØ	×Ñà	‡N�Nð€�ó ð G€ˆeÓ Fð  %×0Ñ0°%·*±*¸e×>QÑ>QÐSX×S]ÑS]Ð^Ð �eÓ ^÷A
ñ A
÷HDñ D÷NYñ Y÷>S!ñ S!ôl*,˜Lô *,÷ZP
ñ P
ôf7�9ô 7ó6ð  !Ø ðLØ	ðLà
ðLð ðLð ð	Lð
 ðLð ðLð ðLð óL÷^#ñ #ð0 �s˜C �}Ñ%€ô&rL   