Ë
    pPêj]  ã                  ó”  — d dl mZ d dlZd dlmZ d dlmZ d dlmZ d dl	m
Z
 d dl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mZmZmZ d d
lmZ d dl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„Z.dd„Z/dd„Z0d d„Z1d!d„Z2d"d„Z3 G d„ de«      Z4	 	 	 	 	 	 	 	 	 	 	 	 d#d„Z5 G d„ de«      Z6d$d„Z7 G d„ d«      Z8d%d„Z9y)&é    )ÚannotationsN)Údefaultdict)ÚCallable)Ú
cmp_to_key)ÚState)Úformat_type)ÚPYTHON_EXTENSIONS)ÚLDEFÚ	DecoratorÚ
ExpressionÚFuncBaseÚ
MemberExprÚMypyFileÚNodeÚOverloadedFuncDefÚRefExprÚ
SymbolNodeÚTypeInfoÚVar)ÚFineGrainedBuildManager)ÚExtendedTraverserVisitor)Útuple_fallback)	ÚFunctionLikeÚInstanceÚLiteralTypeÚ
ProperTypeÚ	TupleTypeÚTypedDictTypeÚTypeVarTypeÚ	UnionTypeÚget_proper_type)Úfill_typevars_with_anyc                ód   — | j                   |kD  xs  | j                   |k(  xr | j                  |kD  S ©N)ÚlineÚcolumn©Úor%   r&   s      úU/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/mypy/inspections.pyÚnode_starts_afterr*   *   s+   € Ø�6‰6�D‰=Ò@˜AŸF™F d™NÒ@¨q¯x©x¸&Ñ/@Ð@ó    c                ó�   — | j                   �:| j                  �.| j                   |k  s| j                   |k(  r| j                  |k  ryy)NTF)Úend_lineÚ
end_columnr'   s      r)   Únode_ends_beforer/   .   s?   € ð 	‡z�zÐ !§,¡,Ð":Ø�:‰:˜Ò §
¡
¨dÒ 2°q·|±|ÀfÒ7LØØr+   c                ór   — | j                   › d| j                  dz   › d| j                  › d| j                  › �S )z1Format expression span as in mypy error messages.ú:é   )r%   r&   r-   r.   )Úexprs    r)   Ú	expr_spanr4   7   s5   € à�i‰iˆ[˜˜$Ÿ+™+¨™/Ð*¨!¨D¯M©M¨?¸!¸D¿O¹OÐ;LÐMÐMr+   c                ó†  — t        | t        «      r| gS t        | t        «      rt        | «      gS t        | t        «      r| j
                  gS t        | t        «      r| j
                  gS t        | t        «      r| j
                  gS t        | t        «      rb| j                  r8g }| j                  D ]%  }|j                  t        t        |«      «      «       Œ' |S t        t        | j                  «      «      S t        | t        «      r8g }| j                  D ]%  }|j                  t        t        |«      «      «       Œ' |S g S )zBReturns the Instance fallback for this type if one exists or None.)Ú
isinstancer   r   r   r   Úfallbackr   r   r   ÚvaluesÚextendÚget_instance_fallbackr!   Úupper_boundr    Úitems)ÚtypÚresÚts      r)   r:   r:   <   s  € ä�#”xÔ ØˆuˆÜ	�CœÔ	#Ü˜sÓ#Ð$Ð$Ü	�CœÔ	'Ø—‘ˆ~ÐÜ	�CœÔ	&Ø—‘ˆ~ÐÜ	�CœÔ	%Ø—‘ˆ~ÐÜ	�CœÔ	%Ø�:Š:ØˆCØ—Z‘Zò F�Ø—
‘
Ô0´ÀÓ1CÓDÕEðFàˆJÜ$¤_°S·_±_Ó%EÓFÐFÜ	�CœÔ	#ØˆØ—‘ò 	BˆAØ�J‰JÔ,¬_¸QÓ-?Ó@ÕAð	Bàˆ
Ø€Ir+   c                ób  — |j                  | «      }|rit        |t        «      r|j                  S |j                  r?t        |t
        «      sJ ‚|j                  d   }t        |t        «      sJ ‚|j                  S |S |j                  | «      }|r|j                  nd}t        |t        «      r|S y)z7Find the node defining member 'name' in given TypeInfo.r   N)
Ú
get_methodr6   r   ÚvarÚis_propertyr   r<   ÚgetÚnoder   )ÚnameÚinfoÚmethodÚdecrE   Úvs         r)   Ú	find_noderK   W   sœ   € ð �_‰_˜TÓ"€FÙÜ�fœiÔ(Ø—:‘:ÐØ×ÒÜ˜fÔ&7Ô8Ð8Ð8Ø—,‘,˜q‘/ˆCÜ˜c¤9Ô-Ð-Ð-Ø—7‘7ˆNØˆð �x‰x˜‹~ˆÙˆD�IŠI 4ˆÜ�aœÔØˆHØr+   c                ó|   — | }||v r||   S 	 d|vry|j                  dd¬«      \  }}|j                  |«      }|�|S Œ1)znFind module by a node fullname.

    This logic mimics the one we use in fixup, so should be good enough.
    ú.Nr2   ©Úmaxsplit)ÚrsplitrD   )ÚfullnameÚmodulesÚheadÚtailÚmods        r)   Úfind_module_by_fullnamerV   m   s\   € ð
 €Dð ˆw�Ø�t‰}ÐØ
Ø�d‰?ØØ—[‘[ ¨q�[Ó1‰
ˆˆdØ�k‰k˜$ÓˆØˆ?ØˆJð r+   c                  ó    — e Zd ZdZdd„Zdd„Zy)ÚSearchVisitorzGVisitor looking for an expression whose span matches given one exactly.c                óJ   — || _         || _        || _        || _        d | _        y r$   )r%   r&   r-   r.   Úresult)Úselfr%   r&   r-   r.   s        r)   Ú__init__zSearchVisitor.__init__ƒ   s%   € ØˆŒ	ØˆŒØ ˆŒØ$ˆŒØ)-ˆ�r+   c                óœ  — t        || j                  | j                  «      ryt        || j                  | j
                  «      ry|j                  | j                  k(  rb|j                  | j                  k(  rI|j                  | j                  k(  r0|j
                  | j
                  k(  rt        |t        «      r|| _        | j                  d u S )NF)	r*   r%   r&   r/   r-   r.   r6   r   rZ   ©r[   r(   s     r)   ÚvisitzSearchVisitor.visitŠ   s�   € Ü˜Q §	¡	¨4¯;©;Ô7ØÜ˜A˜tŸ}™}¨d¯o©oÔ>Øà�F‰F�d—i‘iÒØ—
‘
˜dŸm™mÒ+Ø—‘˜DŸK™KÒ'Ø—‘ §¡Ò/ä˜!œZÔ(Ø�”Ø�{‰{˜dÐ"Ð"r+   N)
r%   Úintr&   r`   r-   r`   r.   r`   ÚreturnÚNone©r(   r   ra   Úbool©Ú__name__Ú
__module__Ú__qualname__Ú__doc__r\   r_   © r+   r)   rX   rX   €   s   „ ÙQó.ô#r+   rX   c                ó¢   — ||k  rt        d«      ‚||k(  r||k  rt        d«      ‚t        ||||«      }| j                  |«       |j                  S )z=Find an expression matching given span, or None if not found.z$"end_line" must not be before "line"z#"end_column" must be after "column")Ú
ValueErrorrX   ÚacceptrZ   )Útreer%   r&   r-   r.   Úvisitors         r)   Úfind_by_locationrp   š   sX   € ð �$‚ÜÐ?Ó@Ð@Ø�4Ò˜J¨&Ò0ÜÐ>Ó?Ð?Ü˜D &¨(°JÓ?€GØ‡K�K�ÔØ�>‰>Ðr+   c                  ó    — e Zd ZdZdd„Zdd„Zy)ÚSearchAllVisitorzGVisitor looking for all expressions whose spans enclose given position.c                ó.   — || _         || _        g | _        y r$   )r%   r&   rZ   )r[   r%   r&   s      r)   r\   zSearchAllVisitor.__init__ª   s   € ØˆŒ	ØˆŒØ(*ˆ�r+   c                óâ   — t        || j                  | j                  «      ryt        || j                  | j                  «      ryt	        |t
        «      r| j                  j                  |«       y)NFT)r*   r%   r&   r/   r6   r   rZ   Úappendr^   s     r)   r_   zSearchAllVisitor.visit¯   sO   € Ü˜Q §	¡	¨4¯;©;Ô7ØÜ˜A˜tŸy™y¨$¯+©+Ô6ØÜ�aœÔ$Ø�K‰K×Ñ˜qÔ!Ør+   N)r%   r`   r&   r`   ra   rb   rc   re   rj   r+   r)   rr   rr   §   s   „ ÙQó+ô
r+   rr   c                óx   — t        ||«      }| j                  |«       t        t        |j                  «      «      S )zFFind all expressions enclosing given position starting from innermost.)rr   rm   ÚlistÚreversedrZ   )rn   r%   r&   ro   s       r)   Úfind_all_by_locationry   ¹   s.   € ä˜t VÓ,€GØ‡K�K�ÔÜ”˜Ÿ™Ó(Ó)Ð)r+   c                  ó@  — e Zd ZdZddddddddœ	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 dd„Zdd„Zdd„Zdd„Zdd	„Z	 	 	 	 	 	 d d
„Z	dd„Z
d!d„Zd"d„Z	 	 	 	 	 	 d#d„Zdd„Zd$d„Zd$d„Zd%d„Z	 	 	 	 	 	 	 	 	 	 	 	 	 	 d&d„Z	 	 	 	 	 	 	 	 	 	 d'd„Zd(d„Z	 	 	 	 	 	 d)d„Zd*d„Zd*d„Zd*d„Zy)+ÚInspectionEnginez:Engine for locating and statically inspecting expressions.r   F)Ú	verbosityÚlimitÚinclude_spanÚinclude_kindÚinclude_object_attrsÚunion_attrsÚforce_reloadc               ó‚   — || _         || _        || _        || _        || _        || _        || _        || _        d | _        y r$   )	Ú
fg_managerr|   r}   r~   r   r€   r�   r‚   Úmodule)	r[   r„   r|   r}   r~   r   r€   r�   r‚   s	            r)   r\   zInspectionEngine.__init__Ã   sH   € ð %ˆŒØ"ˆŒØˆŒ
Ø(ˆÔØ(ˆÔØ$8ˆÔ!Ø&ˆÔØ(ˆÔà$(ˆ�r+   c                óø  — | j                   j                  j                  j                  }d| j                   j                  j                  _        	 | j                   j	                  «        |j
                  €J ‚| j                   j                  |j                  |j
                  fgg «       || j                   j                  j                  _        y# || j                   j                  j                  _        w xY w)z4Reload given module while temporary exporting types.TN)r„   ÚmanagerÚoptionsÚexport_typesÚflush_cacheÚpathÚupdateÚid)r[   ÚstateÚolds      r)   Úreload_modulezInspectionEngine.reload_moduleÚ   s¯   € à�o‰o×%Ñ%×-Ñ-×:Ñ:ˆØ7;ˆ�‰×Ñ×'Ñ'Ô4ð	?Ø�O‰O×'Ñ'Ô)Ø—:‘:Ð)Ð)Ð)Ø�O‰O×"Ñ" U§X¡X¨u¯z©zÐ$:Ð#;¸RÔ@à;>ˆD�O‰O×#Ñ#×+Ñ+Õ8ø¸3ˆD�O‰O×#Ñ#×+Ñ+Õ8ús   ÁAC Ã'C9c                ó  — | j                   j                  j                  j                  |«      }|€| j	                  |«      dfS t        || j                   j                  j                  | j                  ¬«      }| j                  ||«      dfS )zÝFormat type for an expression using current options.

        If type is known, second item returned is True. If type is not known, an error
        message is returned instead, and second item returned is False.
        F)r|   T)	r„   r‡   Ú	all_typesrD   Úmissing_typer   rˆ   r|   Úadd_prefixes)r[   Ú
expressionÚ	expr_typeÚtype_strs       r)   r–   zInspectionEngine.expr_typeå   s   € ð —O‘O×+Ñ+×5Ñ5×9Ñ9¸*ÓEˆ	ØÐØ×$Ñ$ ZÓ0°%Ð7Ð7äØ�t—‘×.Ñ.×6Ñ6À$Ç.Á.ô
ˆð × Ñ  ¨:Ó6¸Ð<Ð<r+   c                ó¾   — | j                   j                  d   j                  }|€J ‚|j                  d   j                  }t        |t        «      sJ ‚t        |g «      S )NÚbuiltinsÚobject)r„   Úgraphrn   ÚnamesrE   r6   r   r   )r[   r™   Úobject_nodes      r)   Úobject_typezInspectionEngine.object_typeô   sY   € Ø—?‘?×(Ñ(¨Ñ4×9Ñ9ˆØÐ#Ð#Ð#Ø—n‘n XÑ.×3Ñ3ˆÜ˜+¤xÔ0Ð0Ð0Ü˜ RÓ(Ð(r+   c                ó:  — dd„}d	d„}|sJ ‚g }|D ][  }i }|j                   j                  }| j                  s|dd }|D ]  }t        |j                  «      ||<   Œ |j                  |«       Œ]  ||d   «      }	|dd D ]  }
|	 ||
«      z  }	Œ t        t        «      }|D ]=  }
|
D ]6  }||v rŒ|
|   D ]'  }| j                  s||	v sŒ||   j                  |«       Œ) Œ8 Œ? t        |j                  «       t        |«      ¬«      }i }|D ]  }||   sŒ	||   ||<   Œ |S )
z3Collect attributes from all union/typevar variants.c                óJ   — t        «       }| D ]  }|t        | |   «      z  }Œ |S r$   )Úset)Ú	attr_dictÚattrsÚbases      r)   Ú
item_attrsz2InspectionEngine.collect_attrs.<locals>.item_attrsþ   s0   € Ü“EˆEØ!ò .�Øœ˜Y t™_Ó-Ñ-‘ð.àˆLr+   c                ó@   — | |j                   v ry|| j                   v ryy)Nr2   éÿÿÿÿr   )Úmro)ÚxÚys     r)   Ú	cmp_typesz1InspectionEngine.collect_attrs.<locals>.cmp_types  s!   € Ø�A—E‘E‰zØØ�A—E‘E‰zØØr+   Nr§   r   r2   )Úkey)r¢   údict[TypeInfo, list[str]]ra   zset[str])r©   r   rª   r   ra   r`   )Útyper¨   r€   Úsortedrœ   ru   r   rw   r�   Úkeysr   )r[   Ú	instancesr¥   r«   Ú	all_attrsÚinstancer£   r¨   r¤   ÚintersectionÚitemÚcombined_attrsrF   Úsorted_basesrZ   s                  r)   Úcollect_attrszInspectionEngine.collect_attrsû   sp  € ó	ó	ñ ÐˆyØˆ	Ø!ò 	$ˆHØˆEØ—-‘-×#Ñ#ˆCØ×,Ò,Ø˜#˜2�h�Øò 1�Ü$ T§Z¡ZÓ0��d’ð1à×Ñ˜UÕ#ð	$ñ " )¨A¡,Ó/ˆØ˜a˜b�Mò 	-ˆDØ™J tÓ,Ñ,‰Lð	-ô
 %¤TÓ*ˆØò 	:ˆDØò :�Ø˜>Ñ)ØØ  ™Jò :�DØ×'Ò'¨4°<Ò+?Ø& tÑ,×3Ñ3°DÕ9ñ:ñ:ð	:ô ˜n×1Ñ1Ó3¼ÀIÓ9NÔOˆØˆØ ò 	0ˆDØ! $Ò'àØ)¨$Ñ/ˆF�4ŠLð		0ð
 ˆr+   c           	     óä   — |D ]f  }| j                   dk  r|j                  n|j                  }||   D �cg c]  }d|› d�‘Œ
 }}|j                  d|› ddj	                  |«      › d�«       Œh y c c}w )Nr2   ú"z": [ú, ú])r|   rF   rQ   ru   Újoin)r[   Ú
attrs_strsÚ
attrs_dictr¤   Úcls_nameÚattrr£   s          r)   Ú_fill_from_dictz InspectionEngine._fill_from_dict1  sy   € ð ò 	EˆDØ$(§N¡N°QÒ$6�t—y’y¸D¿M¹MˆHØ-7¸Ñ-=Ö> T�q˜˜˜a’[Ð>ˆEÐ>Ø×Ñ  ( ¨4°·	±	¸%Ó0@Ð/AÀÐCÕDñ	Eùâ>s   ´A-c           	     óÀ  — | j                   j                  j                  j                  |«      }|€| j	                  |«      dfS t        |«      }t        |«      }|s| j                  «       g}| j                  |«      }t        |t        «      rut        |j                  t        «      r[|j                  }t        |j                  «      }d|v r|j                  d«       d|j                   › d�|D �cg c]  }d|› d�‘Œ
 c}i}ni }t        |t"        «      rD|j%                  «       r4t'        |j)                  «       «      }	| j                  t        |	«      «      }
ni }
g }|r0|D ]+  }|j+                  |› ddj-                  ||   «      › d�«       Œ- | j/                  ||
«       | j/                  ||«       | j1                  d	dj-                  |«      › d
�|«      dfS c c}w )av  Format attributes that are valid for a given expression.

        If expression type is not an Instance, try using fallback. Attributes are
        returned as a JSON (ordered by MRO) that maps base class name to list of
        attributes. Attributes may appear in multiple bases if overridden (we simply
        follow usual mypy logic for creating new Vars etc).
        FÚ__builtins__z"<z>"rº   z: [r»   r¼   ú{ú}T)r„   r‡   r’   rD   r“   r!   r:   rž   r¸   r6   r   rE   r   r¯   rœ   ÚremoverQ   r   Úis_type_objr"   Útype_objectru   r½   rÂ   r”   )r[   r•   r–   r±   r¿   rE   rœ   rF   Úmod_dictÚtemplateÚ
class_dictÚ
base_attrsrU   s                r)   Ú
expr_attrszInspectionEngine.expr_attrs9  sÅ  € ð —O‘O×+Ñ+×5Ñ5×9Ñ9¸*ÓEˆ	ØÐØ×$Ñ$ ZÓ0°%Ð7Ð7ä# IÓ.ˆ	Ü)¨)Ó4ˆ	Ùà×)Ñ)Ó+Ð,ˆIà×'Ñ'¨	Ó2ˆ
ô �j¤'Ô*¬z¸*¿/¹/Ì8Ô/TØ—?‘?ˆDÜ˜4Ÿ:™:Ó&ˆEØ Ñ&à—‘˜^Ô,Ø˜TŸ]™]˜O¨2Ð.ÈÖ0OÀ°1°T°F¸!²Ò0OÐP‰HàˆHô �i¤Ô.°9×3HÑ3HÔ3JÜ-¨i×.CÑ.CÓ.EÓFˆHØ×+Ñ+Ô,AÀ(Ó,KÓL‰JàˆJð ˆ
ÙØò J�Ø×!Ñ! S E¨¨T¯Y©Y°xÀ±}Ó-EÐ,FÀaÐ"HÕIðJà×Ñ˜Z¨Ô4Ø×Ñ˜Z¨Ô4Ø× Ñ  2 d§i¡i°
Ó&;Ð%<¸BÐ!?ÀÓLÈdÐRÐRùò' 1Ps   Ã2Gc                ór   — |j                   › d|j                  › d|j                  dz   › d|j                  › �S )Nr1   r2   )r‹   r%   r&   rF   )r[   r…   rE   s      r)   Úformat_nodezInspectionEngine.format_nodei  s4   € Ø—+‘+�˜a §	¡	˜{¨!¨D¯K©K¸!©OÐ+<¸A¸d¿i¹i¸[ÐIÐIr+   c                ó”  — |j                   }|�€5t        |t        «      �r |j                  �€| j                  j
                  j                  j                  |j                  «      }|€g S t        |«      }t        |«      }g }|D ]6  }t        |j                  |j                  «      }|sŒ&|j                  |«       Œ8 |sƒt        |t        «      ro|j!                  «       r_t        t#        |j%                  «       «      «      }|D ]6  }t        |j                  |j                  «      }|sŒ&|j                  |«       Œ8 |S g S g S |S |g}|S )z‘Collect nodes that can be referred to by an expression.

        Note: it can be more than one for example in case of a union attribute.
        )rE   r6   r   Úkindr„   r‡   r’   rD   r3   r!   r:   rK   rF   r®   ru   r   rÈ   r"   rÉ   )r[   r•   rE   Ú	base_typer±   Únodesr³   s          r)   Úcollect_nodeszInspectionEngine.collect_nodesl  s2  € ð
 .8¯_©_ˆà‰<ä˜*¤jÕ1°j·o±oÑ6MØ ŸO™O×3Ñ3×=Ñ=×AÑAÀ*Ç/Á/ÓR�	ØÐ$Ø�Iô ,¨IÓ6�	Ü1°)Ó<�	Ø�Ø )ò +�HÜ$ Z§_¡_°h·m±mÓD�DÚØŸ™ TÕ*ð+ñ ä! )¬\Ô:¸y×?TÑ?TÔ?VÜ$9Ü2°9×3HÑ3HÓ3JÓKó%˜	ð )2ò 3˜HÜ#,¨Z¯_©_¸h¿m¹mÓ#L˜DÚ#Ø %§¡¨TÕ 2ð3ð ˆð  "˜	à�	ð ˆð �FˆEØˆr+   c                ó¬  — i }d}|D ]È  }t        |j                  | j                  j                  «      }|s-|j                  t
        k(  r| j                  r| j                  }nŒ\|||<   |j                  r#|j                  j                  s| j                  sŒ�||j                   xs |j                  j                  z  }| j                  |«       ŒÊ ||fS )z Gather modules where given nodes where defined.

        Also check if they need to be refreshed (cached nodes may have
        lines/columns missing).
        F)rV   rQ   r„   r›   rÒ   r
   r…   rn   Úis_cache_skeletonr‚   r�   )r[   rÔ   r•   rR   Úreload_neededrE   r…   s          r)   Úmodules_for_nodesz"InspectionEngine.modules_for_nodes–  s¶   € ð ˆØˆØò 
	+ˆDÜ,¨T¯]©]¸D¿O¹O×<QÑ<QÓRˆFÙØ—?‘?¤dÒ*¨t¯{ª{Ø!Ÿ[™[‘FàØ"ˆG�D‰MØ—;’; &§+¡+×"?Ò"?À4×CTÓCTØ V§[¡[ Ò!Q°F·K±K×4QÑ4QÑQ�Ø×"Ñ" 6Õ*ð
	+ð ˜Ð%Ð%r+   c                ó¼  — t        |t        «      sy| j                  |«      }|s| j                  |«      dfS | j	                  ||«      \  }}|r*| j                  |«      }| j	                  ||«      \  }}|rJ ‚g }|D ]&  }|j                  | j                  ||   |«      «       Œ( |s| j                  |«      dfS | j                  dj                  |«      |«      dfS )z Find and format definition location for an expression.

        If it is not a RefExpr, it is effectively skipped by returning an
        empty result.
        )Ú TFr»   T)	r6   r   rÕ   Úmissing_noderÙ   ru   rÐ   r”   r½   )r[   r•   rÔ   rR   rØ   rZ   rE   s          r)   Úexpression_defzInspectionEngine.expression_def­  sõ   € ô ˜*¤gÔ.àà×"Ñ" :Ó.ˆáØ×$Ñ$ ZÓ0°%Ð7Ð7à!%×!7Ñ!7¸¸zÓ!JÑˆ�Ùð ×&Ñ& zÓ2ˆEØ%)×%;Ñ%;¸EÀ:Ó%NÑ"ˆG�]Ù$Ð$Ð$àˆØò 	AˆDØ�M‰M˜$×*Ñ*¨7°4©=¸$Ó?Õ@ð	Añ Ø×$Ñ$ ZÓ0°%Ð7Ð7à× Ñ  §¡¨6Ó!2°JÓ?ÀÐEÐEr+   c                óZ   — d}| j                   sd}dt        |«      j                  › d|› d�S )NrÛ   z or try --force-reloadzNo known type available for "z" (maybe unreachableú))r‚   r®   rf   )r[   r•   Úalt_suggestions      r)   r“   zInspectionEngine.missing_typeÍ  s@   € ØˆØ× Ò Ø5ˆNà+¬D°Ó,<×,EÑ,EÐ+Fð G"Ø"0Ð!1°ð4ð	
r+   c                óJ   — dt        |«      j                  › dt        |«      › �S )NzCannot find definition for "z" at )r®   rf   r4   )r[   r•   s     r)   rÜ   zInspectionEngine.missing_nodeÖ  s*   € à*¬4°
Ó+;×+DÑ+DÐ*EÀUÌ9ÐU_ÓK`ÐJaÐbð	
r+   c                óø   — g }| j                   r%|j                  t        |«      j                  › «       | j                  r|j                  t        |«      «       |rdj                  |«      dz   }||z   S d}||z   S )Nr1   z -> rÛ   )r   ru   r®   rf   r~   r4   r½   )r[   rZ   r•   ÚprefixesÚprefixs        r)   r”   zInspectionEngine.add_prefixesÛ  sw   € ØˆØ×ÒØ�O‰Oœt JÓ/×8Ñ8Ð9Ô;Ø×ÒØ�O‰OœI jÓ1Ô2ÙØ—X‘X˜hÓ'¨&Ñ0ˆFð ˜‰Ðð ˆFØ˜‰Ðr+   c                óÌ   — 	 t        |||dz
  ||«      }|€|› d|› d|› d|› �}	d|	› �dddœS  ||«      \  }
}|
d|rddœS ddœS # t        $ r}dt        |«      icY d}~S d}~ww xY w)	zzGet type of an expression matching a span.

        Type or error is returned as a standard daemon response dict.
        r2   ÚerrorNr1   zCan't find expression at span rÛ   ©ÚoutÚerrÚstatusr   )rp   rl   Ústr)r[   rn   r%   r&   r-   r.   rH   r•   ré   ÚspanÚinspection_strÚsuccesss               r)   Ú run_inspection_by_exact_locationz1InspectionEngine.run_inspection_by_exact_locationç  s�   € ð	'Ü)¨$°°f¸q±jÀ(ÈJÓWˆJð ÐØ�V˜1˜V˜H A h Z¨q°°Ð=ˆDØ;¸D¸6ÐBÈ2ÐYZÑ[Ð[á"(¨Ó"4Ñˆ˜Ø%¨bÁ¸AÑPÐPÈaÑPÐPøô ò 	'ØœS ›XÐ&Õ&ûð	'ús   ‚A Á	A#ÁAÁA#ÁA#c                ó  — t        |||dz
  «      }|s|› d|› �}d|› �dddœS g }d}|D ]%  }	 ||	«      \  }
}|sd}|
sŒ|j                  |
«       Œ' | j                  r|d| j                   }dj                  |«      d|dœS )	z‰Get types of all expressions enclosing a position.

        Types and/or errors are returned as a standard daemon response dict.
        r2   r1   z'Can't find any expressions at position rÛ   rç   r   Nú
)ry   ru   r}   r½   )r[   rn   r%   r&   rH   ÚexpressionsÚpositionÚinspection_strsrê   r•   rí   rî   s               r)   Úrun_inspection_by_positionz+InspectionEngine.run_inspection_by_position   sµ   € ô +¨4°°vÀ±zÓBˆÙØ˜˜q  Ð)ˆHà@ÀÀ
ÐKØØñð ð ˆØˆØ%ò 	7ˆJÙ&,¨ZÓ&8Ñ#ˆN˜GÙØ�ÚØ×&Ñ& ~Õ6ð	7ð �:Š:Ø-¨l°·
±
Ð;ˆOØ—y‘y Ó1¸"ÈÑOÐOr+   c                ó  ‡‡— t        ˆfd„t        D «       «      sdddifS t        j                  j	                  ‰«      Št        ˆfd„| j                  j                  j                  «       D «       d«      }|| _	        ||€
d‰› �ddd	œfS i fS )
z�Find module by path, or return a suitable error message.

        Note we don't use exceptions to simplify handling 1 vs 2 statuses.
        c              3  ó@   •K  — | ]  }‰j                  |«      –— Œ y ­wr$   )Úendswith)Ú.0ÚextÚfiles     €r)   ú	<genexpr>z/InspectionEngine.find_module.<locals>.<genexpr>%  s   øè ø€ ÒC¨#�4—=‘= ×%ÑCùs   ƒNræ   z Source file is not a Python filec              3  óB   •K  — | ]  }|j                   ‰k(  sŒ|–— Œ y ­wr$   )Úabspath)rù   ÚsÚabs_paths     €r)   rü   z/InspectionEngine.find_module.<locals>.<genexpr>+  s   øè ø€ ÒY˜AÀ1Ç9Á9ÐPXÓCX”aÑYùs   ƒ˜zUnknown module: rÛ   r2   rç   )
Úanyr	   Úosr‹   rþ   Únextr„   r›   r8   r…   )r[   rû   rŽ   r   s    ` @r)   Úfind_modulezInspectionEngine.find_module   s–   ù€ ô
 ÓCÔ1BÔCÔCØ˜'Ð#EÐFÐFÐFô —7‘7—?‘? 4Ó(ˆÜÓY §¡×!6Ñ!6×!=Ñ!=Ó!?ÔYÐ[_Ó`ˆØˆŒàØJOÈ-Ð& t fÐ-°bÀAÑFð
ð 	
à]_ð
ð 	
r+   c                ó  — 	 t        |«      \  }}| j                  |«      \  }}|€|sJ ‚|S |j                  r"|j                  j
                  s| j                  r| j                  |«       |j                  €J ‚t        |«      dk(  r'|\  }}	}
}| j                  |j                  ||	|
||«      S t        |«      dk(  sJ ‚|\  }}	| j                  |j                  ||	|«      S # t        $ r}dt        |«      icY d}~S d}~ww xY w)z{Top-level logic to inspect expression(s) at a location.

        This can be reused by various simple inspections.
        ræ   Né   é   )Úparse_locationrl   rë   r  rn   r×   r‚   r�   Úlenrï   rõ   )r[   ÚlocationrH   rû   Úposré   rŽ   Úerr_dictr%   r&   r-   r.   s               r)   Úrun_inspectionzInspectionEngine.run_inspection2  s  € ð	'Ü& xÓ0‰IˆD�#ð ×*Ñ*¨4Ó0‰ˆˆxØˆ=ÙˆO�8ØˆOð �zŠz˜UŸZ™Z×9Ò9¸T×=NÒ=NØ×Ñ˜uÔ%Ø�z‰zÐ%Ð%Ð%äˆs‹8�qŠ=à14Ñ.ˆD�&˜( JØ×8Ñ8Ø—
‘
˜D &¨(°JÀóð ô �3‹x˜1Š}Ðˆ}à‰ˆˆfØ×.Ñ.¨u¯z©z¸4ÀÈÓPÐPøô- ò 	'ØœS ›XÐ&Õ&ûð	'ús   ‚C! Ã!	DÃ*C<Ã6DÃ<Dc                ó:   — | j                  || j                  «      S )z)Get types of expression(s) at a location.)r  r–   ©r[   r
  s     r)   Úget_typezInspectionEngine.get_typeS  s   € à×"Ñ" 8¨T¯^©^Ó<Ð<r+   c                ó:   — | j                  || j                  «      S )z.Get attributes of expression(s) at a location.)r  rÎ   r  s     r)   Ú	get_attrszInspectionEngine.get_attrsW  s   € à×"Ñ" 8¨T¯_©_Ó=Ð=r+   c                ó–   — | j                  || j                  «      }d|v r(|d   s#|j                  dd¬«      \  }}d|› �|d<   d|d<   |S )z6Get symbol definitions of expression(s) at a location.rè   r1   r2   rN   z!No name or member expressions at rê   )r  rÝ   Úsplit)r[   r
  rZ   Ú_s       r)   Úget_definitionzInspectionEngine.get_definition[  s\   € à×$Ñ$ X¨t×/BÑ/BÓCˆØ�F‰? 6¨%¢=à"Ÿ.™.¨°q˜.Ó9‰KˆAˆxØ?À¸zÐJˆF�5‰MØ ˆF�8ÑØˆr+   N)r„   r   r|   r`   r}   r`   r~   rd   r   rd   r€   rd   r�   rd   r‚   rd   ra   rb   )rŽ   r   ra   rb   )r•   r   ra   ztuple[str, bool])ra   r   )r±   úlist[Instance]ra   r­   )r¾   z	list[str]r¿   r­   ra   rb   )r…   r   rE   zFuncBase | SymbolNodera   rë   )r•   r   ra   úlist[FuncBase | SymbolNode])rÔ   r  r•   r   ra   z/tuple[dict[FuncBase | SymbolNode, State], bool])r•   r   ra   rë   )rZ   rë   r•   r   ra   rë   )rn   r   r%   r`   r&   r`   r-   r`   r.   r`   rH   ú(Callable[[Expression], tuple[str, bool]]ra   údict[str, object])
rn   r   r%   r`   r&   r`   rH   r  ra   r  )rû   rë   ra   z&tuple[State | None, dict[str, object]])r
  rë   rH   r  ra   r  )r
  rë   ra   r  )rf   rg   rh   ri   r\   r�   r–   rž   r¸   rÂ   rÎ   rÐ   rÕ   rÙ   rÝ   r“   rÜ   r”   rï   rõ   r  r  r  r  r  rj   r+   r)   r{   r{   À   s¸  „ ÙDð ØØ"Ø"Ø%*Ø!Ø"ñ)à+ð)ð ð	)ð
 ð)ð ð)ð ð)ð #ð)ð ð)ð ð)ð 
ó)ó.	?ó=ó)ó4ðlEØ#ðEØ1JðEà	óEó.Só`Jó(ðT&Ø0ð&Ø>Eð&à	8ó&ó.Fó@
ó
ó

ðQàðQð ðQð ð	Qð
 ðQð ðQð 9ðQð 
óQð2PàðPð ðPð ð	Pð
 9ðPð 
óPó@
ð$QØðQØ%MðQà	óQóB=ó>ôr+   r{   c                óˆ  — | j                  d«      dk  rt        d«      ‚| j                  dd¬«      }|^}}|j                  d«      dk  r||D �cg c]  }t        |«      ‘Œ c}fS |j                  dd¬«      }|^}}|j                  d«      dk  r|||z   D �cg c]  }t        |«      ‘Œ c}fS t        d«      ‚c c}w c c}w )Nr1   r  z7Format should be file:line:column[:end_line:end_column]rN   )Úcountrl   rP   r`   )r
  ÚpartsÚstartÚrestÚpÚ
start_rests         r)   r  r  f  sÇ   € Ø‡~�~�cÓ˜QÒÜÐRÓSÐSØ�O‰O˜C¨!ˆOÓ,€EØ€L€EˆDà‡{�{�3Ó˜!ÒØ tÖ, !”s˜1•vÒ,Ð,Ð,Ø�L‰L˜ qˆLÓ)€EØÐ€EˆJØ‡{�{�3Ó˜!ÒØ z°DÑ'8Ö9 !”s˜1•vÒ9Ð9Ð9Ü
ÐNÓ
OÐOùò -ùò :s   ÁB:ÂB?)r(   r   r%   r`   r&   r`   ra   rd   )r3   r   ra   rë   )r=   r   ra   r  )rF   rë   rG   r   ra   zVar | FuncBase | None)rQ   rë   rR   zdict[str, State]ra   zState | None)rn   r   r%   r`   r&   r`   r-   r`   r.   r`   ra   zExpression | None)rn   r   r%   r`   r&   r`   ra   zlist[Expression])r
  rë   ra   ztuple[str, list[int]]):Ú
__future__r   r  Úcollectionsr   Úcollections.abcr   Ú	functoolsr   Ú
mypy.buildr   Úmypy.messagesr   Úmypy.modulefinderr	   Ú
mypy.nodesr
   r   r   r   r   r   r   r   r   r   r   r   Úmypy.server.updater   Úmypy.traverserr   Úmypy.typeopsr   Ú
mypy.typesr   r   r   r   r   r   r   r    r!   Úmypy.typevarsr"   r*   r/   r4   r:   rK   rV   rX   rp   rr   ry   r{   r  rj   r+   r)   ú<module>r/     s×   ðÝ "ã 	Ý #Ý $Ý  å Ý %Ý /÷÷ ÷ ó õ 7Ý 3Ý '÷
÷ 
õ 
õ 1óAóóNó
ó6ó,ô&#Ð,ô #ð4
Ø
ð
Øð
Ø'*ð
Ø69ð
ØGJð
àó
ôÐ/ô ó$*÷cñ côLPr+   