Ë
    pPêjSß  ã                  óR  — 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 d dlmZmZ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$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z= d#d
„Z>d#d„Z?d$d„Z@d%d„ZAd&d„ZBd&d„ZCd'd„ZDd(d„ZE	 	 	 	 	 	 	 	 	 	 d)d„ZF	 	 	 d*	 	 	 	 	 	 	 	 	 	 	 d+d„ZGddœ	 	 	 	 	 	 	 d,d„ZH	 	 	 	 	 	 	 	 d-d„ZI	 	 	 	 	 	 	 	 d.d„ZJd/d„ZKd0d„ZLd1d„ZM G d„ de3e'   «      ZNd2d„ZOd3d „ZPd4d!„ZQ	 	 	 	 	 	 	 	 d5d"„ZRy)6é    )Úannotations)ÚCallable)Újoin)Ú
erase_type)Úmap_instance_to_supertype)Ústate)Úare_parameters_compatibleÚfind_memberÚis_callable_compatibleÚis_equivalentÚis_proper_subtypeÚis_same_typeÚ
is_subtype)Úis_recursive_pairÚmake_simplified_unionÚtuple_fallback)%ÚMYPYC_NATIVE_INT_NAMESÚTUPLE_LIKE_INSTANCE_NAMESÚAnyTypeÚCallableTypeÚDeletedTypeÚ
ErasedTypeÚFunctionLikeÚInstanceÚLiteralTypeÚNoneTypeÚ
OverloadedÚ
ParametersÚParamSpecTypeÚPartialTypeÚ
ProperTypeÚ	TupleTypeÚTypeÚTypeAliasTypeÚTypedDictItemÚTypedDictTypeÚTypeGuardedTypeÚ	TypeOfAnyÚTypeTypeÚTypeVarLikeTypeÚTypeVarTupleTypeÚTypeVarTypeÚTypeVisitorÚUnboundTypeÚUninhabitedTypeÚ	UnionTypeÚ
UnpackTypeÚfind_unpack_in_listÚget_proper_typeÚget_proper_typesÚhas_type_varsÚis_named_instanceÚsplit_with_prefix_and_suffixc                ó¦   — t        | |«      rt        | «      S t        || «      rt        |«      S t        j                  r
t	        «       S t        «       S )zRReturn one of types (expanded) if it is a subtype of other, otherwise bottom type.)r   r3   r   Ústrict_optionalr/   r   ©ÚsÚts     úN/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/mypy/meet.pyÚtrivial_meetr>   >   sF   € ä�!�QÔÜ˜qÓ!Ð!Ü	�A�qÔ	Ü˜qÓ!Ð!ä× Ò Ü"Ó$Ð$ä“:Ðó    c                ód  — t        | |«      rt        | |«      S t        | «      } t        |«      }t        | t        «      r¸t        |t        «      r¨| j
                  |j
                  k(  r�| j                  s|j                  rwt        | |«      rk| j                  rO|j                  rCt        | j                  j                  «      t        |j                  j                  «      kD  r| S |S | j                  r| S |S t        | t        «      s0t        |t        «      s t        | |d¬«      r| S t        || d¬«      r|S t        | t        «      r| S t        | t        «      r|S t        | t        «      rt        |t        «      s|| }} t        j                   | |«      \  } }|j#                  t%        | «      «      S )z-Return the greatest lower bound of two types.T©Úignore_promotions)r   r>   r3   Ú
isinstancer   ÚtypeÚextra_attrsr   ÚlenÚattrsr.   r   r   r   r0   r   Únormalize_callablesÚacceptÚTypeMeetVisitorr:   s     r=   Ú
meet_typesrK   K   sR  € ä˜˜AÔô ˜A˜qÓ!Ð!Ü˜Ó€AÜ˜Ó€Aä�!”XÔ¤:¨a´Ô#:¸q¿v¹vÈÏÉÒ?Oð �MŠM˜QŸ]š]´¸QÀÔ0BØ�}Š} §¢Ü�q—}‘}×*Ñ*Ó+¬c°!·-±-×2EÑ2EÓ.FÒFà�HØ�Ø�}Š}Ø�ØˆHä�aœÔ%¬j¸¼KÔ.HÜ˜Q °TÕ:ØˆHÜ˜Q °TÕ:ØˆHä�!”ZÔ ØˆÜ�!”WÔØˆÜ�!”YÔ¬
°1´iÔ(@Ø�!ˆ1ˆô ×#Ñ# A qÓ)�D€A€qà�8‰8”O AÓ&Ó'Ð'r?   c                ó(
  — t        |t        «      r&t        | |j                  d¬«      r| S |j                  S | }|}t	        | «      } t	        |«      }| |k(  r|S t        | t
        «      r|| j                  «       }t        |t
        «      r|j                  «       }n|g}t        |D ��cg c]1  }|D ]*  }t        ||d¬«      st        ||d¬«      rt        ||«      ‘Œ, Œ3 c}}«      S t        | |«      rCt        |t
        «      sJ ‚t        |j                  «       D �cg c]  }t        | |«      ‘Œ c}«      S t        | t        «      rGt        |«      s<t        || j                  «      r&| j                  t        | j                  |«      ¬«      S t        |t        «      rGt        |«      s<t        ||j                  «      r&|j                  t        ||j                  «      ¬«      S t        | |«      s$t         j"                  r
t%        «       S t'        «       S t        |t
        «      r1t        |j                  «       D �cg c]  }t        | |«      ‘Œ c}«      S t        |t(        «      r|S t        |t        «      rt        |j                  | «      r|S t        | t*        «      r]t        |t*        «      rMt+        j,                  t        | j.                  |j.                  «      | j0                  xr |j0                  ¬«      S t        | t*        «      ryt        |t2        «      ri|j4                  j7                  «       rO| j0                  rAt        t+        j,                  | j.                  | j8                  | j:                  d¬«      |«      S |S t        | t2        «      rx| j4                  j<                  r|S t        |t2        «      rD|j4                  j<                  r.|j4                  j<                  j4                  | j4                  u r|S t?        ||«      S t        | t@        t*        tB        f«      rt?        ||«      S t        | tD        «      r\t        |t2        «      rL|j4                  jF                  dk(  r'tI        d„ tK        |jL                  «      D «       «      r|S t?        ||«      S t        | tN        «      rUt        |tN        «      rEt        | jP                  «      r0|j                  t        | jP                  |jP                  «      ¬	«      S |S c c}}w c c}w c c}w )
z7Return the declared type narrowed down to another type.TrA   F©Úupper_bound)Úis_type_form)ÚlineÚcolumnrO   zbuiltins.dictc              3  ó<   K  — | ]  }t        |t        «      –— Œ y ­w©N)rC   r   )Ú.0r<   s     r=   ú	<genexpr>z'narrow_declared_type.<locals>.<genexpr>í   s   è ø€ ò =
Ø'(ŒJ�qœ'×"ñ=
ùs   ‚)Úret_type))rC   r'   r   Ú
type_guardr3   r0   Úrelevant_itemsr   Úis_overlapping_typesr   Únarrow_declared_typeÚis_enum_overlapping_unionr,   r5   rN   Úcopy_modifiedr   r9   r/   r   r   r)   Úmake_normalizedÚitemrO   r   rD   Úis_metaclassrP   rQ   Úalt_promoterK   r"   r   r&   ÚfullnameÚallr4   Úargsr   rV   )	ÚdeclaredÚnarrowedÚoriginal_declaredÚoriginal_narrowedÚdeclared_itemsÚnarrowed_itemsÚdÚnÚxs	            r=   rZ   rZ   u   so  € ô �(œOÔ,ä˜X x×':Ñ':ÈdÕSàˆOØ×"Ñ"Ð"à ÐØ ÐÜ˜xÓ(€HÜ˜xÓ(€Hà�8ÒØ Ð Ü�(œIÔ&Ø!×0Ñ0Ó2ˆÜ�h¤	Ô*Ø%×4Ñ4Ó6‰Nà&˜ZˆNÜ$ð (÷àØ'òð ô )¨¨AÀÕFÜ! ! Q¸%Õ@ô % Q¨Õ*ðØ*óó
ð 	
ô( ! ¨8Ô4ô ˜(¤IÔ.Ð.Ð.Ü$Ø8@×8OÑ8OÓ8QÖR°1Ô! (¨AÕ.ÒRó
ð 	
ô 	�8œ[Ô)ÜÐ/Ô0ÜÐ(¨(×*>Ñ*>Ô?ð ×%Ñ%Ü,¨X×-AÑ-AÐCTÓUð &ó 
ð 	
ô 	�8œ[Ô)ÜÐ/Ô0ÜÐ(¨(×*>Ñ*>Ô?ð ×%Ñ%Ü,Ð->À×@TÑ@TÓUð &ó 
ð 	
ô " (¨HÔ5Ü× Ò Ü"Ó$Ð$ä“:ÐÜ	�HœiÔ	(Ü$Ø8@×8OÑ8OÓ8QÖR°1Ô! (¨AÕ.ÒRó
ð 	
ô 
�HœgÔ	&Ø Ð Ü	�HœkÔ	*¬z¸(×:NÑ:NÐPXÔ/YØˆÜ	�HœhÔ	'¬J°xÄÔ,JÜ×'Ñ'Ü  §¡°·±Ó>Ø!×.Ñ.ÒH°8×3HÑ3Hô
ð 	
ô
 	�8œXÔ&Ü�x¤Ô*Ø�M‰M×&Ñ&Ô(à× Ò ô (Ü×(Ñ(Ø—M‘M¨¯©¸h¿o¹oÐ\aôð "ó	ð ð !Ð Ü	�HœhÔ	'Ø�=‰=×$Ò$à$Ð$ä�x¤Ô*Ø—‘×)Ò)Ø—‘×)Ñ)×.Ñ.°(·-±-Ñ?ð %Ð$ÜÐ+Ð->Ó?Ð?Ü	�Hœy¬(´KÐ@Ô	AÜÐ+Ð->Ó?Ð?Ü	�HœmÔ	,´¸HÄhÔ1Oà�=‰=×!Ñ! _Ò4¼ñ =
Ü,<¸X¿]¹]Ó,Kô=
ô :
ð %Ð$ÜÐ+Ð->Ó?Ð?ä�8œ\Ô*Ü�x¤Ô.Ü˜(×+Ñ+Ô,à×%Ñ%Ü)¨(×*;Ñ*;¸X×=NÑ=NÓOð &ó 
ð 	
ð Ðùó]ùò0 Sùò8 Ss   Â&6T
ÄT
È8Tc                óT  — t        | «      } t        | t        «      r1t        | j                  «      dkD  r| j                  S | j
                  gS t        | t        «      rct        | j
                  «      }t        |t        «      r$t        |j                  j                  d   g «      gS t        t        j                  «      gS t        | t        «      r| j
                  gS t        | t        «      rt        | j                   «      S t        | t"        «      rt        | j                   «      S | gS )a  This function takes any "Union-like" type and returns a list of the available "options".

    Specifically, there are currently exactly three different types that can have
    "variants" or are "union-like":

    - Unions
    - TypeVars with value restrictions
    - Overloads

    This function will return a list of each "option" present in those types.

    If this function receives any other type, we return a list containing just that
    original type. (E.g. pretend the type was contained within a singleton union).

    The only current exceptions are regular TypeVars and ParamSpecs. For these "TypeVarLike"s,
    we return a list containing that TypeVarLike's upper bound.

    This function is useful primarily when checking to see if two types are overlapping:
    the algorithm to check if two unions are overlapping is fundamentally the same as
    the algorithm for checking if two overloads are overlapping.

    Normalizing both kinds of types in the same way lets us reuse the same algorithm
    for both.
    r   éÿÿÿÿ)r3   rC   r,   rF   ÚvaluesrN   r   r   rD   Úmror   r(   Úimplementation_artifactr+   r0   ÚlistÚitemsr   )ÚtyprN   s     r=   Úget_possible_variantsru   þ   sç   € ô2 ˜#Ó
€Cä�#”{Ô#Üˆs�z‰z‹?˜QÒØ—:‘:Ðà—O‘OÐ$Ð$Ü	�CœÔ	'ä% c§o¡oÓ6ˆÜ�k¤8Ô,Ü˜[×-Ñ-×1Ñ1°"Ñ5°rÓ:Ð;Ð;Üœ	×9Ñ9Ó:Ð;Ð;Ü	�CÔ)Ô	*Ø—‘Ð Ð Ü	�CœÔ	#Ü�C—I‘I‹ÐÜ	�CœÔ	$ô �C—I‘I‹Ðàˆuˆr?   c                óÄ   ‡ ‡— t        ‰ t        «      xrM ‰ j                  j                  xr5 t        |t        «      xr# t        ˆˆ fd„|j                  «       D «       «      S )zOReturn True if x is an Enum, and y is an Union with at least one Literal from xc              3  óž   •K  — | ]D  }t        t        |«      xŠt        «      xr# ‰j                  ‰j                  j                  k(  –— ŒF y ­wrS   )rC   r3   r   rD   Úfallback)rT   ÚzÚprl   s     €€r=   rU   z,is_enum_overlapping_union.<locals>.<genexpr>6  sC   øè ø€ ò 
àô œO¨AÓ.Ð.�q´Ó<ÒZÀÇÁÈ1Ï:É:Ï?É?ÑAZÓZñ
ùs   ƒA
A)rC   r   rD   Úis_enumr0   ÚanyrX   )rl   Úyrz   s   ` @r=   r[   r[   0  sX   ù€ ô 	�1”hÓò 	
Ø�F‰F�N‰Nò	
ä�qœ)Ó$ò	
ô ô 
à×%Ñ%Ó'ô
ó 
ð	r?   c                óˆ   ‡ — t        ‰ t        «      xr0 t        |t        «      xr t        ˆ fd„|j                  D «       «      S )z?Return True if x is a Literal and y is an Union that includes xc              3  ó:   •K  — | ]  }‰t        |«      k(  –— Œ y ­wrS   )r3   )rT   ry   rl   s     €r=   rU   z&is_literal_in_union.<locals>.<genexpr>B  s   øè ø€ Ò9¨A�”_ QÓ'Õ'Ñ9ùs   ƒ)rC   r   r0   r|   rs   )rl   r}   s   ` r=   Úis_literal_in_unionr€   =  s:   ø€ ô 	�1”kÓ"ò 	:Ü�qœ)Ó$ò	:äÓ9°·±Ô9Ó9ðr?   c                óX   — t        | t        «      xr | j                  j                  dk(  S ©Nzbuiltins.object)rC   r   rD   ra   )r<   s    r=   Ú	is_objectrƒ   F  s"   € Ü�aœÓ"ÒK q§v¡v§¡Ð:KÑ'KÐKr?   c                ó|   — t        | t        «      xr+ t        |t        «      xr |j                  j                  dk(  S r‚   )rC   r   r   rD   ra   )Út1Út2s     r=   Úis_none_object_overlapr‡   J  s8   € ä�2”xÓ ò 	2Ü�rœ8Ó$ò	2à�G‰G×ÑÐ 1Ñ1ðr?   c               ó~   — |rt        | ||¬«      xs t        || |¬«      S t        | ||¬«      xs t        || |¬«      S )NrA   )r   r   )ÚleftÚrightÚproper_subtyperB   s       r=   Úare_related_typesrŒ   R  sY   € ñ Ü Ø�%Ð+<ô
ò Qä˜u dÐ>OÔPð	Qô ˜$ Ð9JÔKò 
ÌzØ�4Ð+<ôP
ð 	
r?   FNc           	     ó´  ‡‡‡‡— t        | t        «      st        |t        «      ry‰€t        «       Šn| |f‰v ryt        | |«      r‰j	                  | |f«       t        | |f«      \  } }t        | t        «      st        |t        «      rJ d«       ‚t        t        t        f}t        | |«      st        ||«      ryt        j                  svt        | t        «      r#t        j                  | j                  «       «      } t        |t        «      r#t        j                  |j                  «       «      }t        | |f«      \  } }t        | t        «      st        |t        «      r‰ xs t!        | «      xs t!        |«      S t#        | |«      s$t#        || «      st%        | |«      st%        || «      ry‰rt'        | |«      st'        || «      ryt)        | |‰‰¬«      ryt+        | «      }t+        |«      }dˆˆˆfd„Št-        |«      dkD  s.t-        |«      dkD  s t        | t.        «      st        |t.        «      r|D ]  }|D ]  }	 ‰||	«      sŒ  y Œ yt        j                  r"t        | t0        «      t        |t0        «      k7  ryt        | t2        «      rt        |t2        «      rt5        | |‰«      S t7        | |«      rt9        | |‰¬«      S t        | t2        «      r| j:                  } nt        |t2        «      r|j:                  }t=        | «      rt=        |«      rt?        | |‰«      S t        | t@        «      rtC        | «      } nt        |t@        «      rtC        |«      }t        | tD        «      r-t        |tD        «      r ‰| jF                  |jF                  «      S t        | tD        «      st        |tD        «      rdˆfd	„}
 |
| |«      xs	  |
|| «      S t        | tH        «      r"t        |tH        «      rtK        | |‰d‰ d¬
«      S t        | tH        «      st        |tH        «      ryt        | tL        «      r7t        |tL        «      r'tO        | |‰d‰ d¬
«      xs tO        || ‰d‰ dd¬«      S d}d}t        | tL        «      r!t        |tP        «      rtS        d||d¬«      }| }t        |tL        «      r!t        | tP        «      rtS        d| | d¬«      }|}t        tU        |«      tV        «      r|�|€J ‚ ‰||«      S t        | tL        «      r| j:                  } t        |tL        «      r|j:                  }t        | tX        «      rCt        |tX        «      r3| jZ                  |jZ                  k(  r| j:                  } |j:                  }n:yt        | tX        «      r| j:                  } nt        |tX        «      r|j:                  }t        | tP        «      �rVt        |tP        «      �rEt)        | |‰‰¬«      ry|j\                  j^                  dk(  r| j\                  j^                  t`        v ry| j\                  jc                  |j\                  j^                  «      rte        | |j\                  «      } nG|j\                  jc                  | j\                  j^                  «      rte        || j\                  «      }ny|j\                  jf                  �r|j\                  jh                  €J ‚|j\                  jj                  €J ‚|j\                  jh                  }|j\                  jj                  }|j\                  jl                  jn                  |   }t        |tp        «      sJ ‚|jB                  }ts        | jt                  ||«      \  }}}ts        |jt                  ||«      \  }}}|tA        tw        |«      |«      fz   |z   }|tA        tw        |«      |«      fz   |z   }n| jt                  }|jt                  }t-        |«      t-        |«      k(  rty        ˆfd„t{        ||«      D «       «      ryyt]        | «      t]        |«      k7  sJ t]        | «      › dt]        |«      › �«       ‚y)a©  Can a value of type 'left' also be of type 'right' or vice-versa?

    If 'ignore_promotions' is True, we ignore promotions while checking for overlaps.
    If 'overlap_for_overloads' is True, we check for overlaps more strictly (to avoid false
    positives), for example: None only overlaps with explicitly optional types, Any
    doesn't overlap with anything except object, we don't ignore positional argument names.
    TNFz%Unexpectedly encountered partial type)r‹   rB   c                ó@   •— t        | |‰‰‰j                  «       ¬«      S )z˜Encode the kind of overlapping check to perform.

        This function mostly exists, so we don't have to repeat keyword arguments everywhere.
        )rB   Úoverlap_for_overloadsÚ
seen_types)rY   Úcopy)r‰   rŠ   rB   r�   r�   s     €€€r=   Ú_is_overlapping_typesz3is_overlapping_types.<locals>._is_overlapping_typesÀ  s(   ø€ ô
 $ØØØ/Ø"7Ø!—‘Ó(ô
ð 	
r?   é   )Úoverlappingc                ó
  •— t        | |f«      \  } }t        | t        «      r-t        |t        «      r ‰| j                  |j
                  «      S t        | t        «      r¥t        |t        «      r•t        | j                  t        «      rF| j                  j                  j                  }|�	 ‰||«      S |j                  j                  d«      S t        | j                  t        «      r|j                  j                  d«      S y)z-Special cases for type object types overlaps.úbuiltins.typeF)r4   rC   r)   r   r^   rV   r   rD   Úmetaclass_typeÚhas_baser   )r‰   rŠ   Ú	left_metar’   s      €r=   Ú_type_object_overlapz2is_overlapping_types.<locals>._type_object_overlap  sÁ   ø€ ô +¨D°%¨=Ó9‰KˆD�%ä˜$¤Ô)¬j¸ÄÔ.MÙ,¨T¯Y©Y¸¿¹ÓGÐGä˜$¤Ô)¬j¸ÄÔ.IÜ˜dŸi™i¬Ô2Ø $§	¡	§¡× =Ñ =�IØ Ð,Ù4°YÀÓFÐFà Ÿ:™:×.Ñ.¨Ó?Ð?Ü §	¡	¬7Ô3Ø Ÿ:™:×.Ñ.¨Ó?Ð?àr?   )Ú	is_compatr   Úignore_pos_arg_namesÚallow_partial_overlap)r›   r   rœ   Úcheck_args_covariantlyr�   Ú__call__)Úis_operatorzbuiltins.intc              3  ó6   •K  — | ]  \  }} ‰||«      –— Œ y ­wrS   © )rT   Úleft_argÚ	right_argr’   s      €r=   rU   z'is_overlapping_types.<locals>.<genexpr>”  s$   øè ø€ ò á'�H˜iñ & h°	×:ñùó   ƒz vs ©r‰   r#   rŠ   r#   ÚreturnÚbool)>rC   r'   Úsetr   Úaddr4   r    r.   r   r   r   r9   r0   Ú
make_unionrX   r   rƒ   r[   r€   r‡   rŒ   ru   rF   r*   r   r&   Úare_typed_dicts_overlappingÚtyped_dict_mapping_pairÚtyped_dict_mapping_overlaprx   Úis_tupleÚare_tuples_overlappingr"   r   r)   r^   r   r	   r   r   r   r
   r3   r   r   ÚvaluerD   ra   r   r˜   r   Úhas_type_var_tuple_typeÚtype_var_tuple_prefixÚtype_var_tuple_suffixÚdefnÚ	type_varsr+   r7   rc   rr   rb   Úzip)r‰   rŠ   rB   r�   r�   Úillegal_typesÚleft_possibleÚright_possibleÚlÚrrš   ÚcallÚotherÚprefixÚsuffixÚtvtrx   Úleft_prefixÚleft_middleÚleft_suffixÚright_prefixÚright_middleÚright_suffixÚ	left_argsÚ
right_argsr’   s     ```                    @r=   rY   rY   _  s1  û€ ô �$œÔ(¬J°u¼oÔ,NààÐÜ“U‰
Ø
�ˆ˜*Ñ	$ØÜ˜˜uÔ%Ø�‰˜˜e�}Ô%ä" D¨% =Ó1�K€Dˆ%ô �$œÔ$¬
°5¼+Ô(FØ=Ð=Ó=ˆuô !¤*¬kÐ:€MÜ�$˜Ô&¬*°U¸MÔ*JØô
 × Ò Ü�dœIÔ&Ü×'Ñ'¨×(;Ñ(;Ó(=Ó>ˆDÜ�eœYÔ'Ü×(Ñ(¨×)=Ñ)=Ó)?Ó@ˆEÜ&¨¨e }Ó5‰ˆˆeô �$œÔ ¤J¨u´gÔ$>Ø(Ð(ÒO¬I°d«OÒO¼yÈÓ?OÐOô 	" $¨Ô.Ü$ U¨DÔ1Ü˜t UÔ+Ü˜u dÔ+àáÜ! $¨Ô.Ô2HÈÐPTÔ2UØäØˆeÐ$9ÐM^õð ô
 *¨$Ó/€MÜ*¨5Ó1€N÷
ô 	ˆMÓ˜QÒÜˆ~Ó Ò"Ü�dœOÔ,Ü�eœ_Ô-àò 	 ˆAØ#ò  �Ù(¨¨AÕ.Úñ ð	 ð ô ×Ò¤¨D´(Ó!;¼zÈ%ÔQYÓ?ZÒ!ZØô �$œÔ&¬:°e¼]Ô+KÜ*¨4°Ð8MÓNÐNÜ	   uÔ	-ä)¨$°ÐCXÔYÐYÜ	�Dœ-Ô	(Ø�}‰}‰Ü	�Eœ=Ô	)Ø—‘ˆä�„~œ( 5œ/Ü% d¨EÐ3HÓIÐIÜ	�Dœ)Ô	$Ü˜dÓ#‰Ü	�Eœ9Ô	%Ü˜uÓ%ˆô �$œÔ!¤j°¼Ô&AÙ$ T§Y¡Y°·
±
Ó;Ð;ä�$œÔ!¤Z°´xÔ%@õ	ñ( $ D¨%Ó0ÒUÑ4HÈÐPTÓ4UÐUä�$œ
Ô#¬
°5¼*Ô(EÜ(ØØØ+Ø#Ø%:Ð!:Ø"&ô
ð 	
ô �$œ
Ô#¤z°%¼Ô'DØä�$œÔ%¬*°U¼LÔ*Iô &ØØØ+Ø#Ø%:Ð!:Ø"&ô
ò 
ô $ØØØ+Ø#Ø%:Ð!:Ø#'Ø"&ô
ð	
ð" €DØ€EÜ�$œÔ%¬*°U¼HÔ*EÜ˜: u¨eÀÔFˆØˆÜ�%œÔ&¬:°d¼HÔ+EÜ˜: t¨T¸tÔDˆØˆÜ”/ $Ó'¬Ô6ØÐ EÐ$5Ð5Ð5Ù$ T¨5Ó1Ð1ä�$œÔ%Ø�}‰}ˆÜ�%œÔ&Ø—‘ˆä�$œÔ$¬°E¼;Ô)GØ�:‰:˜Ÿ™Ò$ð —=‘=ˆDØ—N‘N‰EàÜ	�Dœ+Ô	&Ø�}‰}‰Ü	�Eœ;Ô	'Ø—‘ˆô �$œÕ!¤j°¼Õ&Aô Ø�%Ð(=ÐQbõ
ð à�:‰:×Ñ .Ò0°T·Y±Y×5GÑ5GÔKaÑ5aØð �9‰9×Ñ˜eŸj™j×1Ñ1Ô2Ü,¨T°5·:±:Ó>‰DØ�Z‰Z× Ñ  §¡×!3Ñ!3Ô4Ü-¨e°T·Y±YÓ?‰Eàà�:‰:×-Ó-à—:‘:×3Ñ3Ð?Ð?Ð?Ø—:‘:×3Ñ3Ð?Ð?Ð?Ø—Z‘Z×5Ñ5ˆFØ—Z‘Z×5Ñ5ˆFØ—*‘*—/‘/×+Ñ+¨FÑ3ˆCÜ˜cÔ#3Ô4Ð4Ð4Ø×)Ñ)ˆHÜ4PØ—	‘	˜6 6ó5Ñ1ˆK˜ kô 8TØ—
‘
˜F Fó8Ñ4ˆL˜,¨ð $¤y´°kÓ1BÀHÓ'MÐ&OÑOÐR]Ñ]ˆIØ%¬´4¸Ó3EÀxÓ)PÐ(RÑRÐUaÑa‰JàŸ	™	ˆIØŸ™ˆJÜˆy‹>œS ›_Ò,ô ó ä+.¨y¸*Ó+Eôô ð àô �‹:œ˜e›Ò$ÐF¬¨d«¨°D¼¸e»¸Ð&FÓFÐ$Ør?   rA   c               óB   — t        t        | «      t        |«      |¬«      S )zMThe same as 'is_overlapping_erased_types', except the types are erased first.rA   )rY   r   )r‰   rŠ   rB   s      r=   Úis_overlapping_erased_typesrË   ¦  s#   € ô  Ü�4Óœ* UÓ+Ð?Pôð r?   c                ó  — | j                   D ]7  }||j                  vr y || j                  |   |j                  |   «      rŒ7 y |j                   D ]7  }|| j                  vr y || j                  |   |j                  |   «      rŒ7 y y)z?Returns 'true' if left and right are overlapping TypeDictTypes.FT)Úrequired_keysrs   )r‰   rŠ   Úis_overlappingÚkeys       r=   r¬   r¬   ¯  s�   € ð
 ×!Ñ!ò ˆØ�e—k‘kÑ!ÙÙ˜dŸj™j¨™o¨u¯{©{¸3Ñ/?Õ@Ùð	ð ×"Ñ"ò ˆØ�d—j‘jÑ ÙÙ˜dŸj™j¨™o¨u¯{©{¸3Ñ/?Õ@Ùð	ð r?   c                óú  ‡— t        | |f«      \  } }t        | |«      xs | } t        || «      xs |}t        | t        «      sJ d| › d�«       ‚t        |t        «      sJ d|› d�«       ‚t	        | j
                  «      }t	        |j
                  «      }|�t        | t        |j
                  «      «      } |�t        |t        | j
                  «      «      }t        | j
                  «      t        |j
                  «      k7  ryt        ˆfd„t        | j
                  |j
                  «      D «       «      syt        |j                  d«      st        | j                  d«      ry ‰| j                  |j                  «      S )z6Returns true if left and right are overlapping tuples.zType z is not a tupleFc              3  ó6   •K  — | ]  \  }} ‰||«      –— Œ y ­wrS   r¢   )rT   r»   r¼   rÎ   s      €r=   rU   z)are_tuples_overlapping.<locals>.<genexpr>ß  s   øè ø€ ÒM©¨¨1‰~˜a ×#ÑMùr¥   úbuiltins.tupleT)r4   Úadjust_tuplerC   r"   r2   rs   Úexpand_tuple_if_possiblerF   rb   r·   r6   Úpartial_fallback)r‰   rŠ   rÎ   Úleft_unpackÚright_unpacks     `  r=   r°   r°   Ç  sJ  ø€ ô # D¨% =Ó1�K€Dˆ%Ü˜˜eÓ$Ò,¨€DÜ˜ Ó%Ò.¨€EÜ�dœIÔ&ÐE¨%°¨v°_Ð(EÓEÐ&Ü�eœYÔ'ÐG¨5°°°Ð)GÓGÐ'ô & d§j¡jÓ1€KÜ& u§{¡{Ó3€LØÐÜ'¨¬c°%·+±+Ó.>Ó?ˆØÐÜ(¨´°D·J±J³Ó@ˆä
ˆ4�:‰:ƒœ#˜eŸk™kÓ*Ò*ØÜÓM´°D·J±JÀÇÁÓ0LÔMÔMØô ˜×/Ñ/Ð1AÔBÔFWØ×ÑÐ/ôGð á˜d×3Ñ3°U×5KÑ5KÓLÐLr?   c                ó  — t        | j                  «      |dz   kD  r| S |dz   t        | j                  «      z
  }g }| j                  D ]§  }t        |t        «      s|j	                  |«       Œ%t        |j                  «      }t        |t        «      r|j                  }nt        |t        «      sJ ‚|}|j                  j                  dk(  sJ ‚|j                  |j                  d   g|z  «       Œ© | j                  |¬«      S )Nr“   rÒ   r   ©rs   )rF   rs   rC   r1   Úappendr3   rD   r+   r   r   ra   Úextendrc   r\   )ÚtupÚtargetÚextraÚ	new_itemsÚitÚunpackedÚinstances          r=   rÔ   rÔ   ë  sí   € Ü
ˆ3�9‰9ƒ~˜ ™
Ò"Øˆ
Ø�Q‰Jœ˜SŸY™Y›Ñ'€EØ€IØ�i‰iò 5ˆÜ˜"œjÔ)Ø×Ñ˜RÔ ØÜ" 2§7¡7Ó+ˆÜ�hÔ 0Ô1Ø×.Ñ.‰Hô ˜h¬Ô1Ð1Ð1ØˆHØ�}‰}×%Ñ%Ð)9Ò9Ð9Ð9Ø×Ñ˜(Ÿ-™-¨Ñ*Ð+¨eÑ3Õ4ð5ð ×Ñ 9ÐÓ-Ð-r?   c                óÔ   — t        | t        «      rX| j                  j                  dk(  r?t        |t        «      r|j                  «       nd}t	        | j                  d   g|z  | «      S y)zGFind out if `left` is a Tuple[A, ...], and adjust its length to `right`rÒ   r“   r   N)rC   r   rD   ra   r"   Úlengthrc   )r‰   r¼   rk   s      r=   rÓ   rÓ      sS   € ä�$œÔ! d§i¡i×&8Ñ&8Ð<LÒ&LÜ$ Q¬	Ô2ˆA�H‰HŒJ¸ˆÜ˜$Ÿ)™) A™,˜¨!Ñ+¨TÓ2Ð2Ør?   c                ó’   — t        | «      } t        | t        «      xs+ t        | t        «      xr | j                  j
                  dk(  S )NrÒ   )r3   rC   r"   r   rD   ra   )rt   s    r=   r¯   r¯     s?   € Ü
˜#Ó
€CÜ�cœ9Ó%ò Ü�3œÓ!ÒK c§h¡h×&7Ñ&7Ð;KÑ&Kðr?   c                  óì   — e Z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d0d„Zd1d„Zd2d„Zd3d„Zd4d„Zd5d„Zy)6rJ   c                ó   — || _         y rS   ©r;   )Úselfr;   s     r=   Ú__init__zTypeMeetVisitor.__init__  s	   € Øˆ�r?   c                ó   — t        | j                  t        «      r&t        j                  r
t        «       S | j                  S t        | j                  t
        «      r| j                  S t        t        j                  «      S rS   )	rC   r;   r   r   r9   r/   r   r(   Úspecial_form©ré   r<   s     r=   Úvisit_unbound_typez"TypeMeetVisitor.visit_unbound_type  sS   € Ü�d—f‘fœhÔ'Ü×$Ò$Ü&Ó(Ð(à—v‘v�Ü˜Ÿ™¤Ô0Ø—6‘6ˆMäœ9×1Ñ1Ó2Ð2r?   c                ó   — | j                   S rS   rè   rí   s     r=   Ú	visit_anyzTypeMeetVisitor.visit_any  ó   € Ø�v‰vˆr?   c                óX  — t        | j                  t        «      rTg }|j                  D ]8  }| j                  j                  D ]  }|j	                  t        ||«      «       Œ Œ: t        |«      S |j                  D �cg c]  }t        || j                  «      ‘Œ }}t        |«      S c c}w rS   )rC   r;   r0   rs   rÚ   rK   r   )ré   r<   Úmeetsrl   r}   s        r=   Úvisit_union_typez TypeMeetVisitor.visit_union_type!  s“   € Ü�d—f‘fœiÔ(Ø "ˆEØ—W‘Wò 3�ØŸ™Ÿ™ò 3�AØ—L‘L¤¨A¨qÓ!1Õ2ñ3ð3ô
 % UÓ+Ð+ð 56·G±GÖ<¨q”Z  4§6¡6Õ*Ð<ˆEÐ<Ü$ UÓ+Ð+ùò =s   Á=B'c                óì   — t         j                  rct        | j                  t        «      s=t        | j                  t
        «      r%| j                  j                  j                  dk(  r|S t        «       S |S r‚   )	r   r9   rC   r;   r   r   rD   ra   r/   rí   s     r=   Úvisit_none_typezTypeMeetVisitor.visit_none_type+  sP   € Ü× Ò Ü˜$Ÿ&™&¤(Ô+Ü˜4Ÿ6™6¤8Ô,°·±·±×1EÑ1EÐIZÒ1Zà�ä&Ó(Ð(àˆHr?   c                ó   — |S rS   r¢   rí   s     r=   Úvisit_uninhabited_typez&TypeMeetVisitor.visit_uninhabited_type6  s   € Øˆr?   c                óÂ   — t        | j                  t        «      rt        j                  r|S | j                  S t        | j                  t
        «      r| j                  S |S rS   )rC   r;   r   r   r9   r/   rí   s     r=   Úvisit_deleted_typez"TypeMeetVisitor.visit_deleted_type9  sC   € Ü�d—f‘fœhÔ'Ü×$Ò$Ø�à—v‘v�Ü˜Ÿ™¤Ô0Ø—6‘6ˆMàˆHr?   c                ó   — | j                   S rS   rè   rí   s     r=   Úvisit_erased_typez!TypeMeetVisitor.visit_erased_typeD  rñ   r?   c                ó¤  — t        | j                  t        «      rœ| j                  j                  |j                  k(  ry| j                  j                  |j                  k(  r| j                  S | j                  j                  | j                  | j                  j                  |j                  «      ¬«      S | j                  | j                  «      S )NrM   )rC   r;   r,   ÚidrN   r\   ÚmeetÚdefaultrí   s     r=   Úvisit_type_varzTypeMeetVisitor.visit_type_varG  s‰   € Ü�d—f‘fœkÔ*¨t¯v©v¯y©y¸A¿D¹DÒ/@Ø�v‰v×!Ñ! Q§]¡]Ò2Ø—v‘v�Ø—6‘6×'Ñ'°D·I±I¸d¿f¹f×>PÑ>PÐRS×R_ÑR_Ó4`Ð'ÓaÐaà—<‘< §¡Ó'Ð'r?   c                ón   — | j                   |k(  r| j                   S | j                  | j                   «      S rS   )r;   r   rí   s     r=   Úvisit_param_specz TypeMeetVisitor.visit_param_specO  s)   € Ø�6‰6�QŠ;Ø—6‘6ˆMà—<‘< §¡Ó'Ð'r?   c                ó  — t        | j                  t        «      rT| j                  j                  |j                  k(  r1| j                  j                  |j                  kD  r| j                  S |S | j                  | j                  «      S rS   )rC   r;   r+   rþ   Úmin_lenr   rí   s     r=   Úvisit_type_var_tuplez$TypeMeetVisitor.visit_type_var_tupleU  sY   € Ü�d—f‘fÔ.Ô/°D·F±F·I±IÀÇÁÒ4EØ!ŸV™VŸ^™^¨a¯i©iÒ7�4—6‘6Ð>¸QÐ>à—<‘< §¡Ó'Ð'r?   c                ó   — t         ‚rS   )ÚNotImplementedErrorrí   s     r=   Úvisit_unpack_typez!TypeMeetVisitor.visit_unpack_type[  s   € Ü!Ð!r?   c           
     óÌ  — t        | j                  t        «      rªt        |j                  «      t        | j                  j                  «      k7  r| j                  | j                  «      S ddlm} |j                  t        | j                  j                  |j                  «      D ��cg c]  \  }} |||«      ‘Œ c}}¬«      S | j                  | j                  «      S c c}}w )Nr   )Ú
join_types)Ú	arg_types)
rC   r;   r   rF   r  r   Ú	mypy.joinr  r\   r·   )ré   r<   r  Ús_aÚt_as        r=   Úvisit_parametersz TypeMeetVisitor.visit_parameters^  s¨   € Ü�d—f‘fœjÔ)Ü�1—;‘;Ó¤3 t§v¡v×'7Ñ'7Ó#8Ò8Ø—|‘| D§F¡FÓ+Ð+Ý,à—?‘?Ü@CÀDÇFÁF×DTÑDTÐVW×VaÑVaÓ@b×c±H°C¸™: c¨3Õ/Ócð #ó ð ð —<‘< §¡Ó'Ð'ùó ds   Â)C 
c                óæ
  — t        | j                  t        «      �r‰|j                  | j                  j                  k(  �r…t	        || j                  «      st	        | j                  |«      �r4g }|j                  j
                  �r| j                  }|j                  j                  €J ‚|j                  j                  €J ‚|j                  j                  }|j                  j                  }|j                  j                  j                  |   }t        |t        «      sJ ‚|j                  }t        |j                  ||«      \  }}	}
t        |j                  ||«      \  }}}|t        t        |	«      |«      fz   |
z   }|t        t        |«      |«      fz   |z   }n"|j                  }| j                  j                  }t!        |||j                  j                  j                  «      D ]�  \  }}}| j#                  ||«      }t        |t        «      rdt        |t        «      r|j%                  |j&                  «       ŒUt        |t(        «      sJ ‚t+        |j                  j-                  |g¬«      «      }|j/                  |«       ŒŸ t        |j                  |«      S t0        j2                  r
t)        «       S t5        «       S |j                  j6                  }|r$|j                  | j                  j                  u r|S | j                  j                  j6                  }|r$|j                  |j                  u r| j                  S t	        || j                  «      r|S t	        | j                  |«      r| j                  S t0        j2                  r
t)        «       S t5        «       S t        | j                  t8        «      rD|j                  j:                  r.t=        j>                  |«      }|�rktA        || j                  «      S t        | j                  t8        «      r{| j                  jC                  «       ra|j                  jE                  «       rGt	        | j                  jF                  |«      r| j                  S | jI                  | j                  «      S t        | j                  tJ        «      rtA        || j                  «      S t        | j                  t        «      rtA        || j                  «      S t        | j                  tL        «      rtA        || j                  «      S t        | j                  tN        «      rtA        || j                  «      S | jI                  | j                  «      S )N©rc   )(rC   r;   r   rD   r   r²   r³   r´   rµ   r¶   r+   r   r7   rc   r"   rr   r·   rÿ   rÛ   rs   r/   r1   r\   rÚ   r   r9   r   r`   r   Úis_protocolr   Úunpack_callback_protocolrK   Úis_type_objr_   rx   r   r)   r   r&   )ré   r<   rc   r;   r¿   rÀ   rÁ   rx   Ús_prefixÚs_middleÚs_suffixÚt_prefixÚt_middleÚt_suffixÚs_argsÚt_argsÚtaÚsaÚtvrÿ   r`   r½   s                         r=   Úvisit_instancezTypeMeetVisitor.visit_instancej  s  € Ü�d—f‘fœhÕ'Ø�v‰v˜Ÿ™Ÿ™Ó$Ü˜a §¡Ô(¬J°t·v±v¸qÕ,Að (*�Dð —v‘v×5Ó5ð !ŸF™F˜Ø Ÿv™v×;Ñ;ÐGÐGÐGØ Ÿv™v×;Ñ;ÐGÐGÐGØ!"§¡×!=Ñ!=˜Ø!"§¡×!=Ñ!=˜ØŸf™fŸk™k×3Ñ3°FÑ;˜Ü)¨#Ô/?Ô@Ð@Ð@Ø#&×#5Ñ#5˜Ü7SØŸF™F F¨Fó8Ñ4˜ (¨Hô 8TØŸF™F F¨Fó8Ñ4˜ (¨Hð "*¬Y´t¸H³~ÀxÓ-PÐ,RÑ!RÐU]Ñ!]˜Ø!)¬Y´t¸H³~ÀxÓ-PÐ,RÑ!RÐU]Ñ!]™à!"§¡˜Ø!%§¡§¡˜Ü&)¨&°&¸!¿&¹&¿+¹+×:OÑ:OÓ&Pò *™
˜˜B Ø#Ÿy™y¨¨RÓ0˜Ü% bÔ*:Ô;ô  *¨$´	Ô:Ø $§¡¨D¯J©JÔ 7Ø (ä'1°$¼Ô'HÐ HÐ'HÜ'1°"×2CÑ2C×2QÑ2QÐX\ÐW]Ð2QÓ2^Ó'_ ØŸ™ DÕ)ð*ô $ A§F¡F¨DÓ1Ð1ä×,Ò,Ü.Ó0Ð0ä'›zÐ)àŸf™f×0Ñ0�Ù ;×#3Ñ#3°t·v±v·{±{Ñ#BØ�HØ"Ÿf™fŸk™k×5Ñ5�Ù ;×#3Ñ#3°q·v±vÑ#=ØŸ6™6�MÜ˜a §¡Ô(Ø�HÜ §¡¨Ô*àŸ6™6�Mä×,Ò,Ü.Ó0Ð0ä'›zÐ)Ü˜Ÿ™¤Ô-°!·&±&×2DÒ2DÜ×0Ñ0°Ó3ˆDÚÜ! $¨¯©Ó/Ð/Ü˜Ÿ™¤Ô-°$·&±&×2DÑ2DÔ2FÈ1Ï6É6×K^ÑK^ÔK`Ü˜$Ÿ&™&Ÿ/™/¨1Ô-Ø—v‘v�Ø—<‘< §¡Ó'Ð'Ü˜Ÿ™¤Ô)Ü˜a §¡Ó(Ð(Ü˜Ÿ™¤	Ô*Ü˜a §¡Ó(Ð(Ü˜Ÿ™¤Ô,Ü˜a §¡Ó(Ð(Ü˜Ÿ™¤Ô.Ü˜a §¡Ó(Ð(Ø�|‰|˜DŸF™FÓ#Ð#r?   c                óÎ  — t        | j                  t        «      �rt        j                  || j                  «      rût        || j                  «      r t        j                  || j                  «      S t        || j                  «      }|j                  «       r|j                  «       j                  sE| j                  j                  «       r$| j                  j                  «       j                  sd|_        t        t        |j                  «      t        «      r| j                  | j                  «      S |S t        | j                  t         «      r”|j                  «       r„|j#                  «       stt%        | j                  j&                  |j)                  «       «      }t        |t*        t        f«      st!        j,                  |«      S | j                  | j                  «      S t        | j                  t.        «      rM| j                  j0                  j2                  r-t        j4                  | j                  «      }|rt%        ||«      S | j                  | j                  «      S )NT)rC   r;   r   r   Úis_similar_callablesr   Úcombine_similar_callablesÚmeet_similar_callablesr  Útype_objectÚis_abstractÚfrom_type_typer3   rV   r/   r   r)   Ú
is_genericrK   r^   Úget_instance_typer   r]   r   rD   r  r  )ré   r<   ÚresultÚresr½   s        r=   Úvisit_callable_typez#TypeMeetVisitor.visit_callable_type¿  sŒ  € Ü�d—f‘fœlÕ+´×0IÑ0IÈ!ÈTÏVÉVÔ0TÜ˜Q §¡Ô'Ü×5Ñ5°a¸¿¹Ó@Ð@Ü+¨A¨t¯v©vÓ6ˆFð —‘” Q§]¡]£_×%@Ò%@Ø—F‘F×&Ñ&Ô(¨T¯V©V×-?Ñ-?Ó-A×-MÒ-Mà(,�Ô%Üœ/¨&¯/©/Ó:¼OÔLà—|‘| D§F¡FÓ+Ð+ØˆMÜ˜Ÿ™¤Ô)¨a¯m©m¬oÀaÇlÁlÄnä˜TŸV™VŸ[™[¨!×*=Ñ*=Ó*?Ó@ˆCÜ˜c¤H¬oÐ#>Ô?Ü×/Ñ/°Ó4Ð4Ø—<‘< §¡Ó'Ð'Ü˜Ÿ™¤Ô)¨d¯f©f¯k©k×.EÒ.EÜ×0Ñ0°·±Ó8ˆDÙÜ! ! TÓ*Ð*Ø�|‰|˜DŸF™FÓ#Ð#r?   c                ó  — | j                   }t        |t        «      rj|j                  |j                  k(  rt	        |j                  «      S t        ||«      r|S t        ||«      r|S t        |j                  |j                  «      S t        | j                   t        «      rM| j                   j                  j                  r-t        j                  | j                   «      }|rt        ||«      S t        |j                  |«      S rS   )r;   rC   r   rs   r   r   rK   rx   r   rD   r  r   r  )ré   r<   r;   r½   s       r=   Úvisit_overloadedz TypeMeetVisitor.visit_overloadedÛ  s¼   € ð �F‰FˆÜ�aœÔ&Ø�w‰w˜!Ÿ'™'Ò!Ü! !§'¡'Ó*Ð*Ü˜A˜qÔ!Ø�Ü˜A˜qÔ!Ø�ä! !§*¡*¨a¯j©jÓ9Ð9Ü˜Ÿ™¤Ô)¨d¯f©f¯k©k×.EÒ.EÜ×0Ñ0°·±Ó8ˆDÙÜ! ! TÓ*Ð*Ü˜!Ÿ*™* aÓ(Ð(r?   c                óp  — t        |j                  «      }t        |j                  «      }|€�|€|j                  «       |j                  «       k(  r]g }t        |j                  «       «      D ]=  }|j	                  | j                  |j                  |   |j                  |   «      «       Œ? |S y|��Œ|��‰|j                  «       |j                  «       k(  �rf||k(  �r`|}|j                  |   }t        |t        «      sJ ‚t        |j                  «      }	|j                  |   }
t        |
t        «      sJ ‚t        |
j                  «      }t        |	t        «      rt        |t        «      sy| j                  |	|«      }t        |t        «      syg }t        |j                  d| |j                  d| «      D ]   \  }}|j	                  t        ||«      «       Œ" g }t        |j                  |dz   d |j                  |dz   d «      D ]   \  }}|j	                  t        ||«      «       Œ" |t        |«      gz   |z   S y|�|}|}|}n
|€J ‚|}|}|}|j                  |   }t        |t        «      sJ ‚t        |j                  «      }t        |t        «      sy|j                  «       |j                  «       dz
  k  ry|}|j                  «       |z
  dz
  }t        t        |j                  «      ||«      \  }}}g }t        ||j                  d| «      D ]&  \  }}|j	                  | j                  ||«      «       Œ( |D ]0  }|j	                  | j                  ||j                  d   «      «       Œ2 |rCt        ||j                  | d «      D ]&  \  }}|j	                  | j                  ||«      «       Œ( |S )aÖ  Meet two tuple types while handling variadic entries.

        This is surprisingly tricky, and we don't handle some tricky corner cases.
        Most of the trickiness comes from the variadic tuple items like *tuple[X, ...]
        since they can have arbitrary partial overlaps (while *Ts can't be split). This
        function is roughly a mirror of join_tuples() w.r.t. to the fact that fixed
        tuples are subtypes of variadic ones but not vice versa.
        Nr“   r   )r2   rs   rä   ÚrangerÚ   rÿ   rC   r1   r3   rD   r   r·   rK   r7   Útuplerc   )ré   r;   r<   Ús_unpack_indexÚt_unpack_indexrs   ÚiÚunpack_indexÚs_unpackÚ
s_unpackedÚt_unpackÚ
t_unpackedrÿ   Úm_prefixÚsiÚtiÚm_suffixÚvariadicÚfixedÚunpackrá   Ú
prefix_lenÚ
suffix_lenr¿   ÚmiddlerÀ   ÚfiÚviÚmis                                r=   Úmeet_tupleszTypeMeetVisitor.meet_tuplesî  sz  € ô -¨Q¯W©WÓ5ˆÜ,¨Q¯W©WÓ5ˆØÐ! nÐ&<Ø�x‰x‹z˜QŸX™X›ZÒ'Ø$&�Ü˜qŸx™x›zÓ*ò D�AØ—L‘L §¡¨1¯7©7°1©:°q·w±w¸q±zÓ!BÕCðDà�ØØÑ%¨.Ñ*Dð �x‰x‹z˜QŸX™X›ZÓ'¨N¸nÓ,LØ-�ØŸ7™7 <Ñ0�Ü! (¬JÔ7Ð7Ð7Ü,¨X¯]©]Ó;�
ØŸ7™7 <Ñ0�Ü! (¬JÔ7Ð7Ð7Ü,¨X¯]©]Ó;�
Ü" :¬xÔ8¼ZÈ
ÔT\Ô=]ØØ—y‘y ¨ZÓ8�Ü! $¬Ô1ØØ')�Ü! !§'¡'¨-¨<Ð"8¸!¿'¹'À-À<Ð:PÓQò 8‘F�B˜Ø—O‘O¤J¨r°2Ó$6Õ7ð8à')�Ü! !§'¡'¨,¸Ñ*:Ð*<Ð"=¸q¿w¹wÀ|ÐVWÑGWÐGYÐ?ZÓ[ò 8‘F�B˜Ø—O‘O¤J¨r°2Ó$6Õ7ð8à¤:¨dÓ#3Ð"4Ñ4°xÑ?Ð?ØØÐ%ØˆHØ)ˆLØ‰Eà!Ð-Ð-Ð-ØˆHØ)ˆLØˆEà—‘ Ñ-ˆÜ˜&¤*Ô-Ð-Ð-Ü" 6§;¡;Ó/ˆÜ˜(¤HÔ-ØØ�<‰<‹>˜HŸO™OÓ-°Ñ1Ò1ØØ!ˆ
Ø—_‘_Ó&¨Ñ3°aÑ7ˆ
Ü!=Ü�%—+‘+Ó 
¨Jó"
Ñˆ�˜ð ˆÜ˜& (§.¡.°°*Ð"=Ó>ò 	,‰FˆB�Ø�L‰L˜Ÿ™ 2 rÓ*Õ+ð	,àò 	:ˆBØ�L‰L˜Ÿ™ 2 x§}¡}°QÑ'7Ó8Õ9ð	:áÜ˜f h§n¡n°j°[°\Ð&BÓCò 0‘��BØ—‘˜TŸY™Y r¨2Ó.Õ/ð0àˆr?   c                óˆ  — t        | j                  t        «      rN| j                  | j                  |«      }|€| j	                  | j                  «      S t        |t        |«      «      S t        | j                  t        «      �r¥| j                  j                  j                  t        v �r.| j                  j                  �r| j                  j                  d   }g }|j                  D ]Û  }t        |t        «      r®t        |j                  «      }t        |t        «      rt        «       }|j
                  }nFt        |t        «      r|j                  j                  dk(  sJ ‚t!        |j                  d   |«      }|}|j#                  t        |j%                  |g¬«      «      «       ŒÁ|j#                  t!        ||«      «       ŒÝ |j%                  |¬«      S t'        || j                  «      r|S | j                  j                  j(                  rt+        || j                  «      r|S | j	                  | j                  «      S )Nr   rÒ   r  rÙ   )rC   r;   r"   rH  r   r   r   rD   ra   r   rc   rs   r1   r3   r+   r/   rK   rÚ   r\   r   r²   r   )	ré   r<   rs   Úargrß   rà   rá   Únew_argrâ   s	            r=   Úvisit_tuple_typez TypeMeetVisitor.visit_tuple_type<  s¾  € Ü�d—f‘fœiÔ(Ø×$Ñ$ T§V¡V¨QÓ/ˆEØˆ}Ø—|‘| D§F¡FÓ+Ð+ä˜U¤N°1Ó$5Ó6Ð6Ü˜Ÿ™¤Õ)à�v‰v�{‰{×#Ñ#Ô'@Ò@ÀTÇVÁVÇ[Ã[Ø—f‘f—k‘k !‘n�Ø(*�	ØŸ'™'ò >�Bä! "¤jÔ1Ü#2°2·7±7Ó#;˜Ü% hÔ0@ÔAä&5Ó&7˜GØ'/×'>Ñ'>™Hô !+¨8´XÔ >Ø$,§M¡M×$:Ñ$:Ð>NÒ$Nðð!Oô '1°·±¸qÑ1AÀ3Ó&G˜GØ'/˜HØ!×(Ñ(¬°H×4JÑ4JÐQXÐPYÐ4JÓ4ZÓ)[Õ\ð "×(Ñ(¬°B¸Ó)<Õ=ð%>ð& —‘¨Y�Ó7Ð7Ü" 1 d§f¡fÔ-à�Ø—‘—‘×4Ò4¼ÀAÀtÇvÁvÔ9Nð �Ø�|‰|˜DŸF™FÓ#Ð#r?   c                ó”  — |j                   xr |j                   }|j                  €|j                  €J ‚|j                  }n9|j                  €|j                  }n t        |j                  |j                  «      }|j                  �@|j                  r4t	        ||j                  «      r|j
                  r|j
                  sd}||fS |j                  �@|j                  r4t	        ||j                  «      r|j
                  r|j
                  sd}||fS t        t        |«      t        «      r|j
                  s|j
                  rd}||fS )zØReturn the type and readonlyness of a meet item.

        If the parent constraints are mutually incompatible, the
        returned type will be None; the overall meet type should
        be UninhabitedType.
        N)	Úreadonlyrt   rK   Úmutabler   ÚrequiredrC   r3   r/   )ré   Únamer;   r<   Úis_readonlyÚ	meet_types         r=   Úresolve_typeddict_item_typez+TypeMeetVisitor.resolve_typeddict_item_typee  s
  € ð —j‘jÒ/ Q§Z¡Zˆà�5‰5ˆ=Ø—5‘5Ð$Ð$Ð$ØŸ™‰IØ�U‰Uˆ]ØŸ™‰Iä" 1§5¡5¨!¯%©%Ó0ˆIð �E‰EÐØ—	’	Ü" 9¨a¯e©eÔ4¸¿ºÈAÏJÊJàˆIð ˜;Ð'Ð'ð �E‰EÐØ—	’	Ü" 9¨a¯e©eÔ4¸¿ºÈAÏJÊJàˆIð ˜;Ð'Ð'ô œ¨	Ó2´OÔDØ�JŠJ˜!Ÿ*š*àˆIà˜;Ð'Ð'r?   c                óì  — t        | j                  t        «      �r| j                  j                  xs |j                  }i }t	        «       }| j                  j                  |«      D ]r  \  }}}| j                  |||«      \  }}	|€| j                  | j                  «      c S |r|	st        t        |«      t        «      rŒZ|||<   |	sŒb|j                  |«       Œt | j                  j                  «       }
| j                  j                  |j                  z  }t        ||||
|¬«      S t        | j                  t        «      rt        || j                  «      r|S | j                  | j                  «      S )N)Ú	is_closed)rC   r;   r&   rV  r©   ÚzipallrT  r   r3   r/   rª   Úcreate_anonymous_fallbackrÍ   r   r   )ré   r<   rV  rs   Úreadonly_keysrQ  Ús_itemÚt_itemrS  rR  rx   rÍ   s               r=   Úvisit_typeddict_typez$TypeMeetVisitor.visit_typeddict_type‹  s:  € Ü�d—f‘fœmÕ,ØŸ™×(Ñ(Ò7¨A¯K©KˆIØ%'ˆEÜ&)£eˆMØ(,¯©¯©°aÓ(8ò ,Ñ$��f˜fØ)-×)IÑ)IÈ$ÐPVÐX^Ó)_Ñ&�	˜;àÐ$ØŸ<™<¨¯©Ó/Ò/ñ Ù'Ü"¤?°9Ó#=¼ÔOð à'��d‘ÚØ!×%Ñ% dÕ+ð#,ð& —v‘v×7Ñ7Ó9ˆHØ ŸF™F×0Ñ0°1·?±?ÑBˆMÜ Ø�} m°XÈôð ô ˜Ÿ™¤Ô)¬j¸¸D¿F¹FÔ.CØˆHà—<‘< §¡Ó'Ð'r?   c                ó  — t        | j                  t        «      r| j                  |k(  r|S t        | j                  t        «      r"t	        |j
                  | j                  «      r|S | j                  | j                  «      S rS   )rC   r;   r   r   r   rx   r   rí   s     r=   Úvisit_literal_typez"TypeMeetVisitor.visit_literal_type­  sV   € Ü�d—f‘fœkÔ*¨t¯v©v¸ª{ØˆHÜ˜Ÿ™¤Ô)¬j¸¿¹ÀTÇVÁVÔ.LØˆHà—<‘< §¡Ó'Ð'r?   c                ó   — J d«       ‚)NzInternal errorr¢   rí   s     r=   Úvisit_partial_typez"TypeMeetVisitor.visit_partial_typeµ  s   € à&Ð&Ó&ˆur?   c                ób  — t        | j                  t        «      r†| j                  |j                  | j                  j                  «      }t        |t
        «      sDt        j                  ||j                  | j                  j                  xr |j                  ¬«      }|S t        | j                  t        «      r%| j                  j                  j                  dk(  r|S t        | j                  t        «      r| j                  || j                  «      S | j                  | j                  «      S )N)rP   rO   r–   )rC   r;   r)   rÿ   r^   r   r]   rP   rO   r   rD   ra   r   r   )ré   r<   rt   s      r=   Úvisit_type_typezTypeMeetVisitor.visit_type_type¹  sÉ   € Ü�d—f‘fœhÔ'Ø—)‘)˜AŸF™F D§F¡F§K¡KÓ0ˆCÜ˜c¤8Ô,Ü×.Ñ.Ø˜aŸf™f°4·6±6×3FÑ3FÒ3YÈ1Ï>É>ô�ð ˆJÜ˜Ÿ™¤Ô)¨d¯f©f¯k©k×.BÑ.BÀoÒ.UØˆHÜ˜Ÿ™¤Ô-Ø—9‘9˜Q §¡Ó'Ð'à—<‘< §¡Ó'Ð'r?   c                ó   — J d|› �«       ‚)Nz!This should be never called, got r¢   rí   s     r=   Úvisit_type_alias_typez%TypeMeetVisitor.visit_type_alias_typeÈ  s   € Ø=Ð9¸!¸Ð=Ó=ˆur?   c                ó   — t        ||«      S rS   )rK   )ré   r;   r<   s      r=   rÿ   zTypeMeetVisitor.meetË  s   € Ü˜!˜QÓÐr?   c                óœ   — t        |t        «      rt        t        j                  «      S t
        j                  r
t        «       S t        «       S rS   )	rC   r.   r   r(   rì   r   r9   r/   r   )ré   rt   s     r=   r   zTypeMeetVisitor.defaultÎ  s7   € Ü�cœ;Ô'Üœ9×1Ñ1Ó2Ð2ä×$Ò$Ü&Ó(Ð(ä“zÐ!r?   N)r;   r!   r§   ÚNone)r<   r.   r§   r!   )r<   r   r§   r!   )r<   r0   r§   r!   )r<   r   r§   r!   )r<   r/   r§   r!   )r<   r   r§   r!   )r<   r   r§   r!   )r<   r,   r§   r!   )r<   r   r§   r!   )r<   r+   r§   r!   )r<   r1   r§   r!   )r<   r   r§   r!   )r<   r   r§   r!   )r<   r   r§   r!   )r<   r   r§   r!   )r;   r"   r<   r"   r§   zlist[Type] | None)r<   r"   r§   r!   )rQ  Ústrr;   r%   r<   r%   r§   ztuple[Type | None, bool])r<   r&   r§   r!   )r<   r   r§   r!   )r<   r    r§   r!   )r<   r)   r§   r!   )r<   r$   r§   r!   ©r;   r#   r<   r#   r§   r!   )rt   r#   r§   r!   )Ú__name__Ú
__module__Ú__qualname__rê   rî   rð   rô   rö   rø   rú   rü   r  r  r  r	  r  r!  r-  r/  rH  rL  rT  r\  r^  r`  rb  rd  rÿ   r   r¢   r?   r=   rJ   rJ     s«   „ óó	3óó,ó	óó	óó(ó(ó(ó"ó
(óS$ój$ó8)ó&Ló\'$ðR$(Øð$(Ø)ð$(Ø.;ð$(à	!ó$(óL (óD(ó'ó(ó>ó ô"r?   rJ   c                ó\  — ddl m}m}  || |«      \  } }g }t        t	        | j
                  «      «      D ]4  }|j                   || j
                  |   |j
                  |   «      «       Œ6 | j                  j                  j                  dk7  r| j                  }n|j                  }| j                  €|j                  }n9|j                  €| j                  }n t        | j                  |j                  «      }| j                  |t        | j                  |j                  «      ||d ¬«      S )Nr   )Úmatch_generic_callablesÚ	safe_joinzbuiltins.function)r  rV   Úinstance_typerx   rQ  )r  rn  ro  r1  rF   r  rÚ   rx   rD   ra   rp  rK   r\   rV   )r<   r;   rn  ro  r  r5  rx   rp  s           r=   r%  r%  Ø  s÷   € ß<á" 1 aÓ(�D€A€qØ€IÜ”3�q—{‘{Ó#Ó$ò DˆØ×Ñ™ 1§;¡;¨q¡>°1·;±;¸q±>ÓBÕCðDð
 	‡z�z‡�×ÑÐ#6Ò6Ø—:‘:‰à—:‘:ˆØ‡�ÐØŸ™‰Ø	
�‰Ð	 ØŸ™‰ä" 1§?¡?°A·O±OÓDˆØ�?‰?ØÜ˜AŸJ™J¨¯
©
Ó3Ø#ØØð ó ð r?   c                ór   — | st        t        j                  «      S | d   }| dd  D ]  }t        ||«      }Œ |S )Nr   r“   )r   r(   rq   rK   )ÚtypesÚmetr<   s      r=   Úmeet_type_listrt  õ  sG   € Ùô ”y×8Ñ8Ó9Ð9Ø
�‰(€CØ�1�2ˆYò !ˆÜ˜˜aÓ ‰ð!à€Jr?   c                ó  — t        | |f«      \  } }t        | t        «      rt        |t        «      rJ ‚t        | t        «      r| |}}nt        |t        «      r|| }}nyt        |t        «      xr |j                  j                  d«      S )a¤  Is this a pair where one type is a TypedDict and another one is an instance of Mapping?

    This case requires a precise/principled consideration because there are two use cases
    that push the boundary the opposite ways: we need to avoid spurious overlaps to avoid
    false positives for overloads, but we also need to avoid spuriously non-overlapping types
    to avoid false positives with --strict-equality.
    Fútyping.Mapping)r4   rC   r&   r   rD   r˜   )r‰   rŠ   Ú_r¾   s       r=   r­   r­      sz   € ô # D¨% =Ó1�K€Dˆ%Ü˜$¤Ô.´jÀÌÔ6VÐVÐVä�$œÔ&Ø˜ˆ5‰Ü	�Eœ=Ô	)Ø˜$ˆ5‰àÜ�eœXÓ&ÒP¨5¯:©:×+>Ñ+>Ð?OÓ+PÐPr?   c                óà  ‡‡
‡— t        | |f«      \  } }t        | t        «      rt        |t        «      rJ ‚t        | t        «      rt        |t        «      sJ ‚| |cŠ
}n)t        | t        «      sJ ‚t        |t        «      sJ ‚|| cŠ
}t	        d„ |j
                  j                  D «       d«      }|�‰
j                  ryt	        d„ |j
                  j                  D «       «      }t        ||«      }t        |j                  «      \  }Š‰
j                  «       }|j
                  j                  d   j                  d   }t        |t        «      rt        ‰t        «      r‰
j                   S ‰
j                  r* ‰||«      syt        ˆˆ
ˆfd„‰
j                  D «       «      S  ‰||«      syt        ‰
j                   j#                  «       «      ‰
j                  z
  }	t%        ˆˆ
ˆfd„|	D «       «      S )aS  Check if a TypedDict type is overlapping with a Mapping.

    The basic logic here consists of two rules:

    * A TypedDict with some required keys is overlapping with Mapping[str, <some type>]
      if and only if every key type is overlapping with <some type>. For example:

      - TypedDict(x=int, y=str) overlaps with Dict[str, Union[str, int]]
      - TypedDict(x=int, y=str) doesn't overlap with Dict[str, int]

      Note that any additional non-required keys can't change the above result.

    * A TypedDict with no required keys overlaps with Mapping[str, <some type>] if and
      only if at least one of key types overlaps with <some type>. For example:

      - TypedDict(x=str, y=str, total=False) overlaps with Dict[str, str]
      - TypedDict(x=str, y=str, total=False) doesn't overlap with Dict[str, int]
      - TypedDict(x=int, y=str, total=False) overlaps with Dict[str, str]

    * A TypedDict with at least one ReadOnly[] key does not overlap
      with Dict or MutableMapping, because they assume mutable data.

    As usual empty, dictionaries lie in a gray area. In general, List[str] and List[str]
    are considered non-overlapping despite empty list belongs to both. However, List[int]
    and List[Never] are considered overlapping.

    So here we follow the same logic: a TypedDict with no required keys is considered
    non-overlapping with Mapping[str, <some type>], but is considered overlapping with
    Mapping[Never, Never]. This way we avoid false positives for overloads, and also
    avoid false positives for comparisons like SomeTypedDict == {} under --strict-equality.
    c              3  ó@   K  — | ]  }|j                   d k(  sŒ|–— Œ y­w)ztyping.MutableMappingN©ra   ©rT   Úbases     r=   rU   z-typed_dict_mapping_overlap.<locals>.<genexpr>B  s   è ø€ ÒU�$¨D¯M©MÐ=TÓ,TŒÑUùó   ‚—NFc              3  ó@   K  — | ]  }|j                   d k(  sŒ|–— Œ y­w)rv  Nrz  r{  s     r=   rU   z-typed_dict_mapping_overlap.<locals>.<genexpr>G  s   è ø€ ÒX˜D°d·m±mÐGWÓ6W”4ÑXùr}  r   c              3  óJ   •K  — | ]  } ‰‰j                   |   ‰«      –— Œ y ­wrS   rÙ   ©rT   Úkr”   ÚtypedÚ
value_types     €€€r=   rU   z-typed_dict_mapping_overlap.<locals>.<genexpr>V  s    øè ø€ ÒX¸q‘;˜uŸ{™{¨1™~¨z×:ÑXùó   ƒ #c              3  óJ   •K  — | ]  } ‰‰j                   |   ‰«      –— Œ y ­wrS   rÙ   r€  s     €€€r=   rU   z-typed_dict_mapping_overlap.<locals>.<genexpr>[  s    øè ø€ ÒQ¸q‘;˜uŸ{™{¨1™~¨z×:ÑQùr„  )r4   rC   r&   r   ÚnextrD   rp   rY  r   rc   rX  Úbasesr/   rÍ   rb   r©   rs   Úkeysr|   )r‰   rŠ   r”   r¾   Úmutable_mappingÚmappingÚkey_typerx   Ústr_typeÚnon_requiredr‚  rƒ  s     `       @@r=   r®   r®     s¨  ú€ ôD # D¨% =Ó1�K€Dˆ%Ü˜$¤Ô.´jÀÌÔ6VÐVÐVä�$œÔ&Ü˜%¤Ô*Ð*Ð*Ø˜Uˆˆ‰uä˜$¤Ô)Ð)Ð)Ü˜%¤Ô/Ð/Ð/Ø˜dˆˆˆuäÙU˜%Ÿ*™*Ÿ.™.ÔUÐW[ó€Oð Ð" u×':Ò':ØäÑX E§J¡J§N¡NÔXÓX€GÜ% e¨WÓ5€EÜ+¨E¯J©JÓ7Ñ€Hˆjð ×.Ñ.Ó0€HØ�}‰}×"Ñ" 1Ñ%×*Ñ*¨1Ñ-€Hô �(œOÔ,´¸JÌÔ1XØ×&Ñ&Ð&Ð&à×ÒÙ˜8 XÔ.ØÜÕXÀE×DWÑDWÔXÓXÐXá˜8 XÔ.ØÜ˜5Ÿ;™;×+Ñ+Ó-Ó.°×1DÑ1DÑDˆÜÕQÀLÔQÓQÐQr?   ri  )rd   r#   re   r#   r§   r#   )rt   r#   r§   ú
list[Type])rl   r!   r}   r!   r§   r¨   )r<   r!   r§   r¨   )r…   r!   r†   r!   r§   r¨   )
r‰   r#   rŠ   r#   r‹   r¨   rB   r¨   r§   r¨   )FFN)r‰   r#   rŠ   r#   rB   r¨   r�   r¨   r�   zset[tuple[Type, Type]] | Noner§   r¨   )r‰   r#   rŠ   r#   rB   r¨   r§   r¨   )r‰   r&   rŠ   r&   rÎ   úCallable[[Type, Type], bool]r§   r¨   )r‰   r#   rŠ   r#   rÎ   r�  r§   r¨   )rÜ   r"   rÝ   Úintr§   r"   )r‰   r!   r¼   r!   r§   zTupleType | None)rt   r#   r§   r¨   )r<   r   r;   r   r§   r   )rr  rŽ  r§   r#   r¦   )r‰   r#   rŠ   r#   r”   r�  r§   r¨   )SÚ
__future__r   Úcollections.abcr   Úmypyr   Úmypy.erasetyper   Úmypy.maptyper   Ú
mypy.stater   Úmypy.subtypesr	   r
   r   r   r   r   r   Úmypy.typeopsr   r   r   Ú
mypy.typesr   r   r   r   r   r   r   r   r   r   r   r   r   r    r!   r"   r#   r$   r%   r&   r'   r(   r)   r*   r+   r,   r-   r.   r/   r0   r1   r2   r3   r4   r5   r6   r7   r>   rK   rZ   ru   r[   r€   rƒ   r‡   rŒ   rY   rË   r¬   r°   rÔ   rÓ   r¯   rJ   r%  rt  r­   r®   r¢   r?   r=   ú<module>rš     sé  ðÝ "å $å Ý %Ý 2Ý ÷÷ ñ ÷ RÑ Q÷&÷ &÷ &÷ &÷ &÷ &÷ &÷ &÷ &õ &óV
ó'(óTFóR/ód
óóLóð

Ø
ð

Øð

Ø04ð

ØIMð

à	ó

ð  $Ø"'Ø04ðDØ
ðDàðDð ðDð  ð	Dð
 .ðDð 
óDðP
 ;@ñØ
ðØðØ37ðà	óðØ
ðØ -ðØ?[ðà	óð0!MØ
ð!MØð!MØ-Ið!Mà	ó!MóH.ó*óôF"�k *Ñ-ô F"óRó:óQð(GRØ
ðGRØðGRØ*FðGRà	ôGRr?   