Ë
    pPêjC ã                  ó  — U d Z ddlmZ ddlmZmZ ddlmZmZm	Z	m
Z
 ddl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mZmZmZmZ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/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZD ddlEmFZF ddlGmHZH erddlImJZJ dZKdeLd<   dZMdeLd<    G d„ d«      ZN	 	 	 	 	 	 	 	 	 	 	 	 	 	 d0d„ZO	 	 d1	 	 	 	 	 	 	 	 	 	 	 d2d„ZP	 	 	 	 	 	 	 	 	 	 	 	 d2d„ZQd3d„ZRd4d„ZS	 	 	 	 	 	 	 	 d5d„ZTd6d„ZUd7d„ZVd8d„ZWd9d„ZXd:d„ZYd:d „ZZd;d!„Z[d<d"„Z\d;d#„Z]d;d$„Z^ G d%„ d&e9e_eN      «      Z`d=d'„Zad>d(„Zb	 	 	 	 	 	 d?d)„Zcd@d*„ZddAd+„Ze	 	 	 	 	 	 	 	 dBd,„ZfdCd-„Zg	 	 	 	 	 	 	 	 dDd.„ZhdEd/„Ziy)FzType inference constraints.é    )Úannotations)ÚIterableÚSequence)ÚTYPE_CHECKINGÚFinalÚ	TypeGuardÚcastN)ÚArgTypeExpander)Úerase_typevars)Úexpand_type_by_instance)Úmap_instance_to_supertype)ÚARG_OPTÚARG_POSÚARG_STARÚ	ARG_STAR2ÚCONTRAVARIANTÚ	COVARIANTÚArgKindÚTypeInfo)%ÚMAX_PROTOCOL_DEPTHÚTUPLE_LIKE_INSTANCE_NAMESÚAnyTypeÚCallableTypeÚDeletedTypeÚ
ErasedTypeÚInstanceÚLiteralTypeÚNoneTypeÚNormalizedCallableTypeÚ
OverloadedÚ
ParametersÚParamSpecTypeÚPartialTypeÚ
ProperTypeÚ	TupleTypeÚTypeÚTypeAliasTypeÚTypedDictTypeÚ	TypeOfAnyÚTypeTypeÚ	TypeVarIdÚTypeVarLikeTypeÚTypeVarTupleTypeÚTypeVarTypeÚTypeVisitorÚUnboundTypeÚUninhabitedTypeÚ	UnionTypeÚ
UnpackTypeÚfind_unpack_in_listÚflatten_nested_tuplesÚget_proper_typeÚhas_recursive_typesÚhas_type_varsÚis_named_instanceÚsplit_with_prefix_and_suffix)Úis_union_with_any)Ú
type_state)ÚArgumentInferContextr   Ú
SUBTYPE_OFé   ÚSUPERTYPE_OFc                  óJ   — e Zd ZU dZded<   dZded<   dd„Zdd„Zdd	„Zdd
„Z	y)Ú
ConstraintzpA representation of a type constraint.

    It can be either T <: type or T :> type (T is a type variable).
    r+   Útype_varr   r&   Útargetc                ó^   — |j                   | _        || _        || _        || _        g | _        y ©N)ÚidrC   ÚoprD   Úorigin_type_varÚextra_tvars)ÚselfrC   rH   rD   s       úU/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/mypy/constraints.pyÚ__init__zConstraint.__init__S   s/   € Ø Ÿ™ˆŒØˆŒð ˆŒØ'ˆÔð 35ˆÕó    c                ól   — d}| j                   t        k(  rd}| j                  › d|› d| j                  › �S )Nz<:z:>ú )rH   r@   rC   rD   )rK   Úop_strs     rL   Ú__repr__zConstraint.__repr___   s7   € ØˆØ�7‰7”lÒ"ØˆFØ—-‘-�  & ¨¨4¯;©;¨-Ð8Ð8rN   c                óZ   — t        | j                  | j                  | j                  f«      S rF   )ÚhashrC   rH   rD   )rK   s    rL   Ú__hash__zConstraint.__hash__e   s    € Ü�T—]‘] D§G¡G¨T¯[©[Ð9Ó:Ð:rN   c                ó²   — t        |t        «      sy| j                  | j                  | j                  f|j                  |j                  |j                  fk(  S )NF)Ú
isinstancerB   rC   rH   rD   )rK   Úothers     rL   Ú__eq__zConstraint.__eq__h   sC   € Ü˜%¤Ô,ØØ—‘˜tŸw™w¨¯©Ð4¸¿¹ÈÏÉÐSX×S_ÑS_Ð8`Ñ`Ð`rN   N)rC   r,   rH   ÚintrD   r&   ÚreturnÚNone)r[   Ústr)r[   rZ   )rX   Úobjectr[   Úbool)
Ú__name__Ú
__module__Ú__qualname__Ú__doc__Ú__annotations__rH   rM   rR   rU   rY   © rN   rL   rB   rB   I   s.   … ñð
 ÓØ	
€BØƒLó
5ó9ó;ôarN   rB   c                ó~	  ‡— g }t        |«      }| j                  «       Šg }g }	g }
d}t        |«      D ].  \  }}|D ]$  }|�Œ| j                  |   t        t
        fv sŒ"d} Œ. Œ0 t        |«      D �]ß  \  }}t        | j                  |   t        «      �rÀ| j                  |   }t        |t        «      sJ ‚g }t        |j                  «      }t        |t        «      r|j                  }n$t        |t        «      r|j                  }nJ d«       ‚|D ]Ÿ  }||   }|€Œ|j                  |||   | j                   |   | j                  |   d¬«      }||   t        k7  st        t        |«      t        «      r|j#                  |«       Œu|j#                  t        |j%                  |g¬«      «      «       Œ¡ t        |t        «      r6|j#                  t'        |t(        t        ||j                  «      «      «       �Œˆt        |t        «      �rE|j*                  d   }t        |t        «      sJ ‚t        |j                  «      }t-        |j*                  «      dz
  }t        |t        «      r9|j#                  t'        |t(        t        |d|  |j                  «      «      «       nct        |t.        «      r|j                  j0                  d	k(  sJ ‚|d|  D ]/  }|j3                  t5        |j6                  d   |t(        «      «       Œ1 |s�Œ—t9        |j*                  dd || d «      D ]%  \  }}|j3                  t5        ||t(        «      «       Œ' �ŒÞJ d«       ‚|D ]ö  }||   }|€Œ‰rŠ| j                  |   t        t
        fv ro|rŒ+|j#                  |j                  |||   d||   «      «       ||   }|
j#                  |t        t
        fvrt:        n|«       |	j#                  |r||   nd«       Œ—|j                  |||   | j                   |   | j                  |   «      }t5        | j                  |   |t(        «      }|j3                  |«       Œø �Œâ ‰rCt=        ˆfd
„|D «       «      s/|s-|j#                  t'        ‰t(        t?        ||
|	d¬«      «      «       t=        d„ | j@                  D «       «      rtC        |«      }|S )zlInfer type variable constraints for a callable and actual arguments.

    Return a list of constraints.
    FNTz-mypy bug: unhandled constraint inference case)Úallow_unpack)Úargsr   r?   úbuiltins.tuplec              3  óP   •K  — | ]  }|j                   ‰j                  k(  –— Œ y ­wrF   )rC   rG   )Ú.0ÚcÚ
param_specs     €rL   ú	<genexpr>z1infer_constraints_for_callable.<locals>.<genexpr>   s   øè ø€ ÒE°A�A—J‘J *§-¡-Õ/ÑEùs   ƒ#&©Ú	arg_typesÚ	arg_kindsÚ	arg_namesÚimprecise_arg_kindsc              3  ó<   K  — | ]  }t        |t        «      –— Œ y ­wrF   )rW   r"   )rk   Úvs     rL   rn   z1infer_constraints_for_callable.<locals>.<genexpr>  s   è ø€ Ò
B¨AŒ:�aœ×'Ñ
Bùó   ‚)"r
   rm   Ú	enumeraterq   r   r   rW   rp   r3   r6   Útyper-   Útuple_fallbackr%   Úpartial_fallbackÚexpand_actual_typerr   ÚappendÚcopy_modifiedrB   r@   ÚitemsÚlenr   ÚfullnameÚextendÚinfer_constraintsrh   Úzipr   Úanyr!   Ú	variablesÚfilter_imprecise_kinds)Úcalleerp   rq   rr   Úformal_to_actualÚcontextÚconstraintsÚmapperÚparam_spec_arg_typesÚparam_spec_arg_namesÚparam_spec_arg_kindsÚincomplete_star_mappingÚiÚactualsÚactualÚunpack_typeÚactual_typesÚunpacked_typeÚtuple_instanceÚactual_arg_typeÚexpanded_actualÚinner_unpackÚinner_unpacked_typeÚ
suffix_lenÚatÚttÚactual_kindÚactual_typerl   rm   s                                @rL   Úinfer_constraints_for_callabler    n   s  ø€ ð %'€KÜ˜WÓ%€Fà×"Ñ"Ó$€JØÐØÐØ*,Ðà#ÐÜÐ 0Ó1ò ‰
ˆˆ7Øò 	ˆFØ‰~ &×"2Ñ"2°1Ñ"5¼(ÄIÐ9NÒ"Nð +/Ð'Ùñ	ðô  Ð 0Ó1ó r*‰
ˆˆ7Ü�f×&Ñ& qÑ)¬:Õ6Ø ×*Ñ*¨1Ñ-ˆKÜ˜k¬:Ô6Ð6Ð6ð
 ˆLä+¨K×,<Ñ,<Ó=ˆMÜ˜-Ô)9Ô:Ø!.×!=Ñ!=‘Ü˜M¬9Ô5Ø!.×!?Ñ!?‘àMÐMÓM�uà!ò �Ø"+¨FÑ"3�Ø"Ð*Øà"(×";Ñ";Ø#Ø˜fÑ%Ø×$Ñ$ QÑ'Ø×$Ñ$ QÑ'Ø!%ð #<ó #�ð ˜VÑ$¬Ò0´JÜ# OÓ4´iô5ð !×'Ñ'¨Õ8ð !×'Ñ'Ü" >×#?Ñ#?ÀoÐEVÐ#?Ó#WÓXõð'ô. ˜-Ô)9Ô:Ø×"Ñ"ÜØ%Ü$Ü! ,°×0LÑ0LÓMóöô ˜M¬9Õ5ð  -×2Ñ2°1Ñ5�Ü! ,´
Ô;Ð;Ð;Ü&5°l×6GÑ6GÓ&HÐ#Ü  ×!4Ñ!4Ó5¸Ñ9�
ÜÐ1Ô3CÔDà×&Ñ&Ü"Ø/Ü(Ü%Ø ,¨\¨z¨kÐ :Ð<O×<^Ñ<^óóõô #Ð#6¼ÔAØ/×4Ñ4×=Ñ=ÐAQÒQððRð +¨<¨Z¨KÐ8ò ˜Ø#×*Ñ*Ü-Ð.A×.FÑ.FÀqÑ.IÈ2Ì|Ó\õðó
 Ü"% m×&9Ñ&9¸!¸"Ð&=¸|ÈZÈKÈLÐ?YÓ"Zò T™˜˜BØ#×*Ñ*Ô+<¸RÀÄ\Ó+RÕSòTð NÐMÓM�uà!ò *�Ø"+¨FÑ"3�Ø"Ð*Øá &×"2Ñ"2°1Ñ"5¼(ÄIÐ9NÑ"Nò
 3Ø,×3Ñ3Ø"×5Ñ5Ø /°¸6Ñ1BÀDÈ)ÐTZÑJ[óôð
 '0°Ñ&7˜Ø,×3Ñ3Ø'2¼8ÄYÐ:OÑ'O�GÐU`ôð -×3Ñ3É°I¸fÒ4EÐX\Õ]à"(×";Ñ";Ø'Ø! &Ñ)Ø×(Ñ(¨Ñ+Ø×(Ñ(¨Ñ+ó	#�Kô *¨&×*:Ñ*:¸1Ñ*=¸{ÌLÓY�AØ×&Ñ& qÕ)ò;*ðkr*ñh 	ÜÓE¸ÔEÔEÙ'ð 	×ÑÜØÜÜØ2Ø2Ø2Ø(,ô	ó	ô	
ô Ñ
B°×1AÑ1AÔ
BÔBä,¨[Ó9ˆØÐrN   c                ó‚  ‡ ‡— t        ˆˆ fd„t        t        j                  «      D «       «      rg S t	        ‰ «      st        t        ‰ «      t        «      r]t        ‰ «      sg S t        j                  j                  ‰ ‰f«       t        ‰ ‰|||«      }t        j                  j                  «        |S t        ‰ ‰|||«      S )aÑ  Infer type constraints.

    Match a template type, which may contain type variable references,
    recursively against a type which does not contain (the same) type
    variable references. The result is a list of type constrains of
    form 'T is a supertype/subtype of x', where T is a type variable
    present in the template and x is a type without reference to type
    variables present in the template.

    Assume T and S are type variables. Now the following results can be
    calculated (read as '(template, actual) --> result'):

      (T, X)            -->  T :> X
      (X[T], X[Y])      -->  T <: Y and T :> Y
      ((T, T), (X, Y))  -->  T :> X and T :> Y
      ((T, S), (X, Y))  -->  T :> X and S :> Y
      (X[T], Any)       -->  T <: Any and T :> Any

    The constraints are represented as Constraint objects. If skip_neg_op == True,
    then skip adding reverse (polymorphic) constraints (since this is already a call
    to infer such constraints).
    c              3  ó„   •K  — | ]7  \  }}t        ‰«      t        |«      k(  xr t        ‰«      t        |«      k(  –— Œ9 y ­wrF   )r6   )rk   ÚtÚar’   Útemplates      €€rL   rn   z$infer_constraints.<locals>.<genexpr>4  sJ   øè ø€ ò ñ ˆQ�ô 	˜Ó!¤_°QÓ%7Ñ7ò 	:Ü˜FÓ#¤°qÓ'9Ñ9ó	:ñùs   ƒ=A )r„   Úreversedr<   Ú	inferringr7   rW   r6   r   r8   r|   Ú_infer_constraintsÚpop)r¥   r’   Ú	directionÚskip_neg_opÚerase_typesÚress   ``    rL   r‚   r‚     s¨   ù€ ô: ô ô œz×3Ñ3Ó4ôô ð
 ˆ	Ü˜8Ô$¬
´?À8Ó3LÌhÔ(Wô ˜XÔ&àˆIÜ×Ñ×#Ñ# X¨vÐ$6Ô7Ü  ¨6°9¸kÈ;ÓWˆÜ×Ñ× Ñ Ô"Øˆ
Ü˜h¨°	¸;ÈÓTÐTrN   c           
     óv  — | }t        | «      } t        |«      }t        j                  s;t        | t        «      r+t
        j                  j                  | j                  d¬«      } t        j                  s;t        |t        «      r+t
        j                  j                  |j                  d¬«      }t        |t        «      r|j                  t        j                  k(  rg S d}t        | «      r#t        |«      rd}t        | «      } t        |«      }t        | t        «      rt!        | ||«      gS t        |t        «      rd|j"                  j%                  «       sJ|t&        k(  rAt        | t        «      rt)        d„ | j                  D «       «      st        |j*                  «      }|t,        k(  rAt        | t        «      r1g }| j                  D ]  }|j/                  t1        |||«      «       Œ  |S |t&        k(  rXt        |t        «      rHg }|j                  D ]5  }	|rt3        j4                  |	«      }	|j/                  t1        ||	|«      «       Œ7 |S |t,        k(  r@t        |t        «      r0t7        |j                  D �	cg c]  }	t9        | |	|«      ‘Œ c}	d¬«      S |t&        k(  rwt        | t        «      rgt7        | j                  D �cg c]  }t9        |||«      ‘Œ c}t        |t        «      ¬«      }
|
r|
S t;        | «      rt;        |«      st=        | ||«      S g S | j?                  tA        ||||«      «      S c c}	w c c}w )NT)Úkeep_erasedFc              3  ó<   K  — | ]  }t        |t        «      –— Œ y ­wrF   )rW   r.   )rk   r£   s     rL   rn   z%_infer_constraints.<locals>.<genexpr>x  s   è ø€ ò :
Ø+,ŒJ�qœ+×&ñ:
ùrv   ©Úeager)!r6   r<   Úkeep_unionsrW   r2   ÚmypyÚtypeopsÚmake_simplified_unionr~   r   Útype_of_anyr)   Úsuggestion_engineÚ_is_type_typeÚ_unwrap_type_typer.   rB   rG   Úis_meta_varr@   r„   Úupper_boundr>   r�   r‚   r*   Úmake_normalizedÚany_constraintsÚinfer_constraints_if_possibler7   Úhandle_recursive_unionÚacceptÚConstraintBuilderVisitor)r¥   r’   rª   r«   r¬   Úorig_templateÚtype_type_unwrappedr­   Út_itemÚa_itemÚresults              rL   r¨   r¨   G  sâ  € ð €MÜ˜xÓ(€HÜ˜VÓ$€Fô
 ×!Ò!¤j°¼9Ô&EÜ—<‘<×5Ñ5°h·n±nÐRVÐ5ÓWˆÜ×!Ò!¤j°¼Ô&CÜ—‘×3Ñ3°F·L±LÈdÐ3ÓSˆô �&œ'Ô" v×'9Ñ'9¼Y×=XÑ=XÒ'XØˆ	ð  ÐÜ�XÔ¤=°Ô#8Ø"ÐÜ$ XÓ.ˆÜ" 6Ó*ˆô �(œKÔ(Ü˜8 Y°Ó7Ð8Ð8ô 	�6œ;Ô'Ø—	‘	×%Ñ%Ô'ØœÒ%ô ˜(¤IÔ.´cñ :
Ø08·±ô:
ô 7
ô % V×%7Ñ%7Ó8ˆFð
 ”JÒ¤:¨h¼	Ô#BØˆØ—n‘nò 	EˆFØ�J‰JÔ(¨°¸ÓCÕDð	Eàˆ
Ø”LÒ ¤Z°¼	Ô%BØˆØ—l‘lò 	LˆFñ #Ü!×1Ñ1°&Ó9�Ø�J‰JÔ(¨¸À	ÓJÕKð	Lð ˆ
ð ”JÒ¤:¨f´iÔ#@ô ð %Ÿl™löàô .¨h¸À	ÕJòð ô
ð 	
ð ”LÒ ¤Z°¼)Ô%Dô !ð 'Ÿn™nöàô .¨f°f¸iÕHòô ˜V¤WÓ-ô
ˆñ ØˆMÜ  Ô*Ô3FÀvÔ3NÜ)¨(°F¸IÓFÐFØˆ	ð �?‰?Ô3°F¸IÀ{ÐT_Ó`ÓaÐaùò1ùòs   É7L1Ë L6c                ó‚   — t        | t        «      xs. t        | t        «      xr t        d„ | j                  D «       «      S )z§Is ``tp`` a ``type[...]`` or a union thereof?

    ``Type[A | B]`` is internally represented as ``type[A] | type[B]``, and this
    troubles the solver sometimes.
    c              3  óN   K  — | ]  }t        t        |«      t        «      –— Œ y ­wrF   )rW   r6   r*   )rk   Úos     rL   rn   z _is_type_type.<locals>.<genexpr>½  s   è ø€ ÒK¸Q”
œ?¨1Ó-¬x×8ÑKùs   ‚#%)rW   r*   r2   Úallr~   )Útps    rL   r¹   r¹   ´  s;   € ô 	�2”xÓ ò 	LÜ�bœ)Ó$ò LÜÑKÀ"Ç(Á(ÔKÓKðrN   c                óà   — t        | t        «      r| j                  S t        j                  | j
                  D �cg c]%  }t        t        t        |«      «      j                  ‘Œ' c}«      S c c}w )zHExtract the inner type from ``type[...]`` expression or a union thereof.)rW   r*   Úitemr2   Ú
make_unionr~   r	   r6   )rÌ   rÊ   s     rL   rº   rº   Á  sM   € ä�"”hÔØ�w‰wˆÜ×ÑÐRT×RZÑRZÖ [ÈQ¤¤h´ÀÓ0BÓ!C×!HÓ!HÒ [Ó\Ð\ùÒ [s   º*A+c                ó‚  — |t         k(  r*t        j                  j                  t	        | «      |«      sy|t
        k(  r*t        j                  j                  |t	        | «      «      sy|t
        k(  rDt        | t        «      r4t        j                  j                  |t	        | j                  «      «      syt        | ||«      S )a2  Like infer_constraints, but return None if the input relation is
    known to be unsatisfiable, for example if template=List[T] and actual=int.
    (In this case infer_constraints would return [], just like it would for
    an automatically satisfied relation like template=List[T] and actual=object.)
    N)
r>   r´   ÚsubtypesÚ
is_subtyper   r@   rW   r.   r¼   r‚   )r¥   r’   rª   s      rL   r¿   r¿   È  s•   € ð ”JÒ¤t§}¡}×'?Ñ'?ÄÈxÓ@XÐZ`Ô'aØØ”LÒ ¬¯©×)AÑ)AØ”˜xÓ(ô*ð à”\Ò!Ü�x¤Ô-Ü—‘×(Ñ(¨´À×@TÑ@TÓ1UÔVð Ü˜X v¨yÓ9Ð9rN   c                óf   — g }| D ])  }|€Œt        d„ |D «       «      sŒ|j                  |«       Œ+ |S )zDSelect only those lists where each item is a constraint against Any.c              3  ób   K  — | ]'  }t        t        |j                  «      t        «      –— Œ) y ­wrF   )rW   r6   rD   r   )rk   rl   s     rL   rn   z!select_trivial.<locals>.<genexpr>ç  s    è ø€ ÒNÀ!Œzœ/¨!¯(©(Ó3´W×=ÑNùs   ‚-/)rË   r|   )Úoptionsr­   Úoptions      rL   Úselect_trivialr×   á  s?   € à
€CØò ˆØˆ>ØÜÑNÀvÔNÕNØ�J‰J�vÕð	ð
 €JrN   c           	     óþ   — | j                   }t        |«      r| S t        t        j                  «      }t        | j                  | j                  t        j                  ||g|j                  |j                  «      «      S )z?Transform a constraint target into a union with given Any type.)rD   r;   r   r)   Úimplementation_artifactrB   rI   rH   r2   rÏ   ÚlineÚcolumn)Ú
constraintrD   Úany_types      rL   Úmerge_with_anyrÞ   ì  sg   € à×Ñ€FÜ˜Ô àÐä”y×8Ñ8Ó9€HÜØ×"Ñ"Ø�‰Ü×Ñ˜f hÐ/°·±¸f¿m¹mÓLóð rN   c                óB  — | j                   D �cg c]  }t        |t        «      rŒ|‘Œ }}| j                   D �cg c]  }t        |t        «      sŒ|‘Œ }}t        t	        j
                  |«      ||«      xs  t        t	        j
                  |«      ||«      S c c}w c c}w rF   )r~   rW   r.   r‚   r2   rÏ   )r¥   r’   rª   r£   Únon_type_var_itemsÚtype_var_itemss         rL   rÀ   rÀ   û  sŒ   € ð &.§^¡^ÖV ¼:ÀaÌÕ;Uš!ÐVÐÐVØ!)§¡ÖN˜A´:¸aÄÕ3M’aÐN€NÐNÜÜ×ÑÐ/Ó0°&¸)óò Tä	œ9×/Ñ/°Ó?ÀÈÓ	SðTùò WùÚNs   �B¥B¹BÁBc          	     ó¨  ‡— |r| D �cg c]  }|sŒ|‘Œ	 c}Šn| D �cg c]  }|€Œ|‘Œ	 c}Š‰sg S t        ‰«      dk(  r‰d   S t        ˆfd„‰dd D «       «      r‰d   S t        ˆfd„‰dd D «       «      rpt        ‰«      }|rct        |«      t        ‰«      k  rLg }‰D ]/  }||v rŒ|j                  |D �cg c]  }t	        |«      ‘Œ c}«       Œ1 t        t        |«      |¬«      S | D �cg c]  }t        |«      ‘Œ }}|| k7  rt        ||¬«      S | D �cg c]  }t        |«      ‘Œ }}|| k7  rt        ||¬«      S g S c c}w c c}w c c}w c c}w c c}w )aE  Deduce what we can from a collection of constraint lists.

    It's a given that at least one of the lists must be satisfied. A
    None element in the list of options represents an unsatisfiable
    constraint and is ignored.  Ignore empty constraint lists if eager
    is true -- they are always trivially satisfiable.
    Nr?   r   c              3  ó<   •K  — | ]  }t        ‰d    |«      –— Œ y­w©r   N)Úis_same_constraints©rk   rl   Úvalid_optionss     €rL   rn   z"any_constraints.<locals>.<genexpr>  s   øè ø€ Ò
O¸Ô˜}¨QÑ/°×3Ñ
Oùó   ƒc              3  ó<   •K  — | ]  }t        ‰d    |«      –— Œ y­wrä   )Úis_similar_constraintsræ   s     €rL   rn   z"any_constraints.<locals>.<genexpr>  s   øè ø€ Ò
R¸1Ô! -°Ñ"2°A×6Ñ
Rùrè   r±   )	r   rË   r×   r|   rÞ   r¾   ÚlistÚfilter_satisfiableÚexclude_non_meta_vars)	rÕ   r²   rÖ   Útrivial_optionsÚmerged_optionsrl   rÊ   Úfiltered_optionsrç   s	           @rL   r¾   r¾     s  ø€ ñ Ø.5Ö@ FºšÒ@‰à.5ÖL F¸Ñ9KšÒLˆáØˆ	ä
ˆ=Ó˜QÒØ˜QÑÐä
Ó
O¸]È1È2Ð=NÔ
OÔOà˜QÑÐä
Ó
RÀÈaÈbÐ@QÔ
RÔRô
 )¨Ó7ˆÙœs ?Ó3´c¸-Ó6HÒHØˆNØ'ò K�Ø˜_Ñ,ØØ×%Ñ%À&Ö&I¸Q¤~°aÕ'8Ò&IÕJðKô #¤4¨Ó#7¸uÔEÐEð 8?Ö?°!Ô*¨1Õ-Ð?ÐÐ?Ø˜7Ò"ÜÐ/°uÔ=Ð=ð ;BÖB°QÔ-¨aÕ0ÐBÐÐBØ˜7Ò"ÜÐ/°uÔ=Ð=ð €IùòY AùâLùò. 'Jùò
 @ùò Cs&   ˆD;�D;œE ¤E Â4E
Ã)E
ÄEc                óž  ‡— | s| S g }| D ]½  Št        ‰j                  t        «      rQ‰j                  j                  r;t	        ˆfd„‰j                  j                  D «       «      sŒ\|j                  ‰«       Œnt        j                  j                  ‰j                  ‰j                  j                  «      sŒ­|j                  ‰«       Œ¿ |sy|S )a  Keep only constraints that can possibly be satisfied.

    Currently, we filter out constraints where target is not a subtype of the upper bound.
    Since those can be never satisfied. We may add more cases in future if it improves type
    inference.
    c              3  ór   •K  — | ].  }t         j                  j                  ‰j                  |«      –— Œ0 y ­wrF   )r´   rÑ   rÒ   rD   )rk   Úvaluerl   s     €rL   rn   z%filter_satisfiable.<locals>.<genexpr>M  s+   øè ø€ ò Ø>C”—‘×(Ñ(¨¯©°5×9ñùs   ƒ47N)rW   rI   r.   Úvaluesr„   r|   r´   rÑ   rÒ   rD   r¼   )rÖ   Úsatisfiablerl   s     @rL   rì   rì   @  s°   ø€ ñ Øˆà€KØò "ˆÜ�a×'Ñ'¬Ô5¸!×:KÑ:K×:RÒ:RÜó ØGH×GXÑGX×G_ÑG_ôõ ð ×"Ñ" 1Õ%Ü�]‰]×%Ñ% a§h¡h°×0AÑ0A×0MÑ0MÕNØ×Ñ˜qÕ!ð"ñ ØØÐrN   c                ór   — | s| S | D �cg c]  }|j                   j                  «       sŒ|‘Œ! c}xs d S c c}w rF   )rC   r»   )rÖ   rl   s     rL   rí   rí   X  s4   € áØˆð Ö:�! §¡×!7Ñ!7Õ!9ŠAÒ:ÒB¸dÐBùÒ:s   ‰4©4c                óz   ‡— | D ]  Št        ˆfd„|D «       «      rŒ y |D ]  Št        ˆfd„| D «       «      rŒ y y)Nc              3  ó6   •K  — | ]  }t        ‰|«      –— Œ y ­wrF   ©Úis_same_constraint©rk   Úc2Úc1s     €rL   rn   z&is_same_constraints.<locals>.<genexpr>c  ó   øè ø€ Ò:°"Ô% b¨"×-Ñ:ùó   ƒFc              3  ó6   •K  — | ]  }t        ‰|«      –— Œ y ­wrF   rù   rû   s     €rL   rn   z&is_same_constraints.<locals>.<genexpr>f  rþ   rÿ   T)r„   )ÚxÚyrý   s     @rL   rå   rå   a  sJ   ø€ Øò ˆÜÓ:¸Ô:Õ:Ùðð ò ˆÜÓ:¸Ô:Õ:Ùðð rN   c                ón  — t        t        | j                  «      t        «      xr# t        t        |j                  «      t        «      }| j                  |j                  k(  xrS | j
                  |j
                  k(  xs |xr4 t        j                  j                  | j                  |j                  «      S rF   )	rW   r6   rD   r   rC   rH   r´   rÑ   Úis_same_type)rý   rü   Úskip_op_checks      rL   rú   rú   k  sƒ   € äœ¨r¯y©yÓ9¼7ÓCò Ì
Ü˜Ÿ	™	Ó"¤GóI€Mð 	�‰�r—{‘{Ñ"ò 	=Ø�U‰U�b—e‘e‰^Ò,˜}ò	=ä�M‰M×&Ñ& r§y¡y°"·)±)Ó<ðrN   c                ó6   — t        | |«      xr t        || «      S )a  Check that two lists of constraints have similar structure.

    This means that each list has same type variable plus direction pairs (i.e we
    ignore the target). Except for constraints where target is Any type, there
    we ignore direction as well.
    )Ú_is_similar_constraints)r  r  s     rL   rê   rê   w  s   € ô # 1 aÓ(ÒJÔ-DÀQÈÓ-JÐJrN   c                ó.  — | D ]�  }d}|D ]ƒ  }t        t        |j                  «      t        «      xs# t        t        |j                  «      t        «      }|j                  |j                  k(  sŒe|j
                  |j
                  k(  s|sŒ�d} n |rŒ� y y)zŠCheck that every constraint in the first list has a similar one in the second.

    See docstring above for definition of similarity.
    FT)rW   r6   rD   r   rC   rH   )r  r  rý   Úhas_similarrü   r  s         rL   r  r  �  sŽ   € ð
 ò ˆØˆØò 	ˆBä&¤°r·y±yÓ'AÄ7ÓKò ÌzÜ §	¡	Ó*¬GóPˆMð �{‰{˜bŸk™kÓ)¨r¯u©u¸¿¹ª~ÂØ"�Ùð	ò Ùðð rN   c                  ó$  — e Zd ZU dZde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.d„Zd/d„Z	 d-	 	 	 	 	 	 	 d0d„Zd1d„Zd2d„Zd3d„Zd4d„Zd5d„Zd6d„Zd7d„Zy)8rÂ   z-Visitor class for inferring type constraints.r$   r’   c                ó<   — || _         || _        || _        || _        y rF   )r’   rª   r«   r¬   )rK   r’   rª   r«   r¬   s        rL   rM   z!ConstraintBuilderVisitor.__init__œ  s&   € ð ˆŒØ"ˆŒð 'ˆÔð 'ˆÕrN   c                ó   — g S rF   re   ©rK   r¥   s     rL   Úvisit_unbound_typez+ConstraintBuilderVisitor.visit_unbound_type­  ó   € Øˆ	rN   c                ó   — g S rF   re   r  s     rL   Ú	visit_anyz"ConstraintBuilderVisitor.visit_any°  r  rN   c                ó   — g S rF   re   r  s     rL   Úvisit_none_typez(ConstraintBuilderVisitor.visit_none_type³  r  rN   c                ó   — g S rF   re   r  s     rL   Úvisit_uninhabited_typez/ConstraintBuilderVisitor.visit_uninhabited_type¶  r  rN   c                ó   — g S rF   re   r  s     rL   Úvisit_erased_typez*ConstraintBuilderVisitor.visit_erased_type¹  r  rN   c                ó   — g S rF   re   r  s     rL   Úvisit_deleted_typez+ConstraintBuilderVisitor.visit_deleted_type¼  r  rN   c                ó   — g S rF   re   r  s     rL   Úvisit_literal_typez+ConstraintBuilderVisitor.visit_literal_type¿  r  rN   c                ó   — J d«       ‚)NzInternal errorre   r  s     rL   Úvisit_partial_typez+ConstraintBuilderVisitor.visit_partial_typeÄ  s   € à&Ð&Ó&ˆurN   c                ó   — J d«       ‚)NzbUnexpected TypeVarType in ConstraintBuilderVisitor (should have been handled in infer_constraints)re   r  s     rL   Úvisit_type_varz'ConstraintBuilderVisitor.visit_type_varÊ  ó   € ð	
ð?ó	
ˆurN   c                ó   — g S rF   re   r  s     rL   Úvisit_param_specz)ConstraintBuilderVisitor.visit_param_specÐ  s   € àˆ	rN   c                ó   — t         ‚rF   )ÚNotImplementedErrorr  s     rL   Úvisit_type_var_tuplez-ConstraintBuilderVisitor.visit_type_var_tupleÔ  s   € Ü!Ð!rN   c                ó   — t        d«      ‚)Nz5Mypy bug: unpack should be handled at a higher level.)ÚRuntimeErrorr  s     rL   Úvisit_unpack_typez*ConstraintBuilderVisitor.visit_unpack_type×  s   € ÜÐRÓSÐSrN   c                óÆ  — t        | j                  t        «      r&| j                  |j                  | j                  «      S t
        j                  r;t        | j                  t        «      r!t        || j                  | j                  «      S t
        j                  rEt        | j                  t        «      r+t        || j                  j                  | j                  «      S g S rF   )rW   r’   r   Úinfer_against_anyrp   r<   Úinfer_polymorphicr!   Ú$infer_callable_arguments_constraintsrª   r"   Úprefixr  s     rL   Úvisit_parametersz)ConstraintBuilderVisitor.visit_parametersÚ  s›   € ä�d—k‘k¤7Ô+Ø×)Ñ)¨(×*<Ñ*<¸d¿k¹kÓJÐJÜ×'Ò'¬J°t·{±{ÄJÔ,Oô 8¸À$Ç+Á+ÈtÏ~É~Ó^Ð^Ü×'Ò'¬J°t·{±{ÄMÔ,Rä7Ø˜$Ÿ+™+×,Ñ,¨d¯n©nóð ð ˆ	rN   c                óÒ$  ‡‡$— | j                   x}}g }t        |t        t        f«      �rŽ‰j                  j
                  �rwd‰j                  j                  v �r^t        ‰j                  j                  «      t        k  �r7t        ˆfd„‰j                  j                  D «       «      �s‰j                  j                  j                  ‰«       t        j                  j                  d‰|d¬«      }|€J ‚| j                  t         k(  r)t        j                  j#                  |t%        |«      «      s<| j                  t&        k(  rOt        j                  j#                  t%        |«      |«      r&|j)                  t+        ||| j                  «      «       ‰j                  j                  j-                  «        t        |t        «      r˜|j.                  �Œ|j1                  «       rp‰j                  j
                  rZ| j                  t         k(  rG|j3                  d¬«      }t        |t4        «      r%|j)                  | j7                  |‰|‰d¬«      «       |j.                  }t        |t8        «      rì‰j                  j
                  rÖ| j                  t         k(  rÃ|j:                  }t        |t4        «      r%|j)                  | j7                  |‰|‰d¬«      «       t        |t<        «      rt?        |j@                  «      }t        |t4        «      rM|j                  jB                  r7|j)                  | j7                  |j                  jB                  ‰|‰«      «       t        |t        «      r|j.                  �|j.                  }t        |tD        «      r|jG                  «       }t        |tH        «      r|j.                  }t        |t4        «      �rW|Š$t%        ‰«      }t        |tJ        «      rt        |t4        «      sJ ‚| j                  t&        k(  �rb‰j                  jM                  ‰$j                  jN                  «      �r2tQ        ‰‰$j                  «      }	|	j                  jR                  jT                  }
‰$j                  jV                  �r‰$j                  jX                  €J ‚‰$j                  jZ                  €J ‚‰$j                  jX                  }‰$j                  jZ                  }‰$j                  jR                  jT                  |   }t        |t\        «      sJ ‚|j^                  }ta        ‰$jb                  ||«      \  }}}ta        |	jb                  ||«      \  }}}|te        tg        |«      |«      fz   |z   }|te        tg        |«      |«      fz   |z   }n|	jb                  }‰$jb                  }ti        |
||«      D �]®  \  }}}t        |t<        «      r}|jj                  tl        k7  r&|j)                  t+        ||| j                  «      «       |jj                  tn        k7  sŒe|j)                  t+        ||tq        | j                  «      «      «       Œ•t        |tr        «      �rÑt        |tr        «      �rÀ|jt                  }t        |tv        «      rµ|jy                  |jz                  t        |jz                  «      d  |j|                  t        |j|                  «      d  |j~                  t        |j~                  «      d  «      }|j                  t�        |t&        |«      «       |j                  t�        |t         |«      «       �Œˆt        |tr        «      s�Œš|jy                  tw        |jt                  jz                  t        |jz                  «      d  |jt                  j|                  t        |j|                  «      d  |jt                  j~                  t        |j~                  «      d  «      ¬«      }|j                  t�        |t&        |«      «       |j                  t�        |t         |«      «       �Œwt        |t\        «      s�Œ‰|j)                  t+        ||| j                  «      «       �Œ± |S | j                  t         k(  �r|‰$j                  jM                  ‰j                  jN                  «      �rLtQ        ‰$‰j                  «      }	‰j                  jR                  jT                  }
‰j                  jV                  �r‰j                  jX                  €J ‚‰j                  jZ                  €J ‚‰j                  jX                  }‰j                  jZ                  }‰j                  jR                  jT                  |   }t        |t\        «      sJ ‚|j^                  }ta        ‰jb                  ||«      \  }}}ta        |	jb                  ||«      \  }}}|te        tg        |«      |«      fz   |z   }|te        tg        |«      |«      fz   |z   }n|	jb                  }‰jb                  }ti        |
||«      D �]È  \  }}} t        |t<        «      r}|jj                  tl        k7  r&|j)                  t+        | || j                  «      «       |jj                  tn        k7  sŒe|j)                  t+        | |tq        | j                  «      «      «       Œ•t        |tr        «      �rÑt        | tr        «      �rÀ| jt                  }t        |tv        «      rµ|jy                  |jz                  t        |jz                  «      d  |j|                  t        |j|                  «      d  |j~                  t        |j~                  «      d  «      }|j                  t�        | t&        |«      «       |j                  t�        | t         |«      «       �Œˆt        |tr        «      s�Œš|jy                  tw        |jt                  jz                  t        |jz                  «      d  |jt                  j|                  t        |j|                  «      d  |jt                  j~                  t        |j~                  «      d  «      ¬«      }|j                  t�        | t&        |«      «       |j                  t�        | t         |«      «       �Œwt        |t\        «      s�Œ‰|j)                  t+        | |t&        «      «       |j)                  t+        | |t         «      «       �ŒË |S ‰j                  j
                  rû| j                  t         k(  rèt        ‰j                  j                  «      t        k  rÂt        ˆfd„tƒ        ‰j                  j                  «      D «       «      s‘t        j                  j…                  ‰$|dg¬	«      rn‰j                  j                  j                  ‰«       |j)                  | j7                  ‰$‰|‰«      «       ‰j                  j                  j-                  «        |S ‰$j                  j
                  rû| j                  t&        k(  rèt        ‰$j                  j                  «      t        k  rÂt        ˆ$fd
„tƒ        ‰$j                  j                  «      D «       «      s‘t        j                  j…                  |‰$dg¬	«      rn‰$j                  j                  j                  ‰$«       |j)                  | j7                  ‰$‰‰‰$«      «       ‰$j                  j                  j-                  «        |S |r|S t        |t†        «      r| j‰                  ‰jb                  |«      S t        |td        «      rÕt‹        ‰tŒ        «      rÅ| j                  t         k(  r²|jŽ                  D ]¡  }!t        |!t�        «      r`t?        |!j                  «      }"t        |"t\        «      rŒ9t        |"t4        «      r|"j                  jN                  dk(  sJ ‚|"jb                  d   }!t+        ‰jb                  d   |!t         «      }#|j)                  |#«       Œ£ |S t        |td        «      �ry| j                  t         k(  �ret        j’                  j_                  |«      Š$t%        ‰«      }t        |tJ        «      rt        |t4        «      sJ ‚‰j                  j
                  rì| j                  t         k(  rÙt        ‰j                  j                  «      t        k  r³t        ˆfd„tƒ        ‰j                  j                  «      D «       «      s‚t        j                  j…                  ‰$|dg¬	«      r_‰j                  j                  j                  ‰«       | j7                  ‰$‰|‰«      }‰j                  j                  j-                  «        |S t+        ‰‰$| j                  «      S t        |t<        «      rI|j”                  s;|j–                  j™                  «       s!t+        ‰|j@                  | j                  «      S g S t        |tr        «      r!t+        ‰|j@                  | j                  «      S t        |t\        «      rtš        ‚g S )NÚ__call__c              3  ó(   •K  — | ]	  }‰|k(  –— Œ y ­wrF   re   ©rk   r£   r¥   s     €rL   rn   z:ConstraintBuilderVisitor.visit_instance.<locals>.<genexpr>ò  s   øè ø€ ò QØ&'�H •MñQùó   ƒT©Úis_operator)Úforce_fallback©Ú	class_obj©r-  c              3  ó(   •K  — | ]	  }‰|k(  –— Œ y ­wrF   re   r2  s     €rL   rn   z:ConstraintBuilderVisitor.visit_instance.<locals>.<genexpr>À  ó   øè ø€ ÒQ¨!˜ A�ÑQùr3  )Úskipc              3  ó(   •K  — | ]	  }‰|k(  –— Œ y ­wrF   re   )rk   r�   Úinstances     €rL   rn   z:ConstraintBuilderVisitor.visit_instance.<locals>.<genexpr>Ñ  r;  r3  ri   r   c              3  ó(   •K  — | ]	  }‰|k(  –— Œ y ­wrF   re   r2  s     €rL   rn   z:ConstraintBuilderVisitor.visit_instance.<locals>.<genexpr>þ  s   øè ø€ ÒU¨a˜H¨�MÑUùr3  )Nr’   rW   r   r    rx   Úis_protocolÚprotocol_membersr   r§   r   r„   r|   r´   rÑ   Úfind_memberrª   r@   rÒ   r   r>   r�   r‚   r©   ÚfallbackÚis_type_objÚget_instance_typer   Ú'infer_constraints_from_protocol_membersr*   rÎ   r.   r6   r¼   Úmetaclass_typer(   Úcreate_anonymous_fallbackr   r$   Úhas_baser€   r   ÚdefnÚ	type_varsÚhas_type_var_tuple_typeÚtype_var_tuple_prefixÚtype_var_tuple_suffixr-   ry   r:   rh   r%   rë   rƒ   Úvariancer   r   Úneg_opr"   r-  r!   r}   rp   rq   rr   rB   r¦   Úis_protocol_implementationr   r*  r9   r   r~   r3   rµ   rô   rG   r»   r$  )%rK   r¥   Úoriginal_actualr’   r­   ÚcallÚinstance_typerÆ   ÚerasedÚmappedÚtvarsÚ
prefix_lenr›   ÚtvtrC  Úi_prefixÚi_middleÚi_suffixÚm_prefixÚm_middleÚm_suffixÚinstance_argsÚmapped_argsÚtvarÚ
mapped_argÚinstance_argr-  ÚsuffixÚt_prefixÚt_middleÚt_suffixÚtemplate_argsÚtemplate_argrÎ   ÚunpackedÚcbr>  s%    `                                  @rL   Úvisit_instancez'ConstraintBuilderVisitor.visit_instanceì  sB  ù€ Ø#'§;¡;Ð.ˆ˜&Ø "ˆÜ�fœ|¬ZÐ8Õ9¸h¿m¹m×>WÓ>WØ˜XŸ]™]×;Ñ;Ò;ä�x—}‘}×.Ñ.Ó/Ô2DÓDÌSó QØ+3¯=©=×+BÑ+BôQõ Nð —M‘M×+Ñ+×2Ñ2°8Ô<ÜŸ=™=×4Ñ4Ø" H¨fÀ$ð 5ó �Dð  Ð+Ð+Ð+àŸ™¬,Ò6Ü ŸM™M×4Ñ4°V¼^ÈDÓ=QÔRØŸ>™>¬ZÒ7Ü ŸM™M×4Ñ4´^ÀDÓ5IÈ6ÔRàŸ
™
Ô#4°T¸6À4Ç>Á>Ó#RÔSØ—M‘M×+Ñ+×/Ñ/Ô1Ü�fœlÔ+°·±Ð0Kà×"Ñ"Ô$Ø—M‘M×-Ò-Ø—N‘N¤lÒ2à &× 8Ñ 8ÈÐ 8Ó M�Ü˜m¬XÔ6Ø—J‘JØ×DÑDØ)¨8°]ÀHÐX\ð Eó ôð
 —_‘_ˆFÜ�fœhÔ'¨H¯M©M×,EÒ,EØ�~‰~¤Ò-ØŸ™�Ü˜f¤hÔ/Ø—J‘JØ×DÑDØ" H¨f°hÈ$ð Eó ôô ˜f¤kÔ2Ü,¨V×-?Ñ-?Ó@�FÜ˜f¤hÔ/°F·K±K×4NÒ4NØ—J‘JØ×DÑDØ"ŸK™K×6Ñ6¸À&È(óôô �fœjÔ)¨f¯o©oÐ.IØ—_‘_ˆFÜ�fœmÔ,Ø×5Ñ5Ó7ˆFÜ�fœkÔ*Ø—_‘_ˆFÜ�fœhÕ'ØˆHÜ# HÓ-ˆFÜ˜f¤jÔ1´jÀÌÔ6RÐRÐRð �~‰~¤Ó+°·±×0FÑ0FÀxÇ}Á}×G]ÑG]Õ0^Ü2°8¸X¿]¹]ÓK�ØŸ™×(Ñ(×2Ñ2�à—=‘=×8Ó8ð $Ÿ=™=×>Ñ>ÐJÐJÐJØ#Ÿ=™=×>Ñ>ÐJÐJÐJØ!)§¡×!DÑ!D�JØ!)§¡×!DÑ!D�JØ"Ÿ-™-×,Ñ,×6Ñ6°zÑB�CÜ% cÔ+;Ô<Ð<Ð<Ø"×1Ñ1�HÜ3OØ Ÿ™ z°:ó4Ñ0�H˜h¨ô 4PØŸ™ Z°ó4Ñ0�H˜h¨ð %-´	¼$¸x».È(Ó0SÐ/UÑ$UÐX`Ñ$`�MØ"*¬i¼¸X»ÈÓ.QÐ-SÑ"SÐV^Ñ"^‘Kà"(§+¡+�KØ$,§M¡M�Mô 7:¸%ÀÈmÓ6\ó #`Ñ2�D˜* lÜ! $¬Ô4ð  Ÿ=™=¬MÒ9ØŸJ™JÔ'8¸À\ÐSW×SaÑSaÓ'bÔcØŸ=™=¬IÓ5ØŸJ™JÜ 1°*¸lÌFÐSW×SaÑSaÓLbÓ cõô $ D¬-Õ8¼ZÈ
ÔTaÕ=bØ!+×!2Ñ!2˜Ü% l´JÔ?ð ,8×+EÑ+EØ ,× 6Ñ 6´s¸6×;KÑ;KÓ7LÐ7NÐ OØ ,× 6Ñ 6´s¸6×;KÑ;KÓ7LÐ7NÐ OØ ,× 6Ñ 6´s¸6×;KÑ;KÓ7LÐ7NÐ Oó,˜Fð
  ŸJ™J¤z°*¼jÈ&Ó'QÔRØŸJ™J¤z°*¼lÈFÓ'SÖTÜ'¨´mÖDØ%1×%?Ñ%?Ü'1Ø$0×$7Ñ$7×$AÑ$AÄ#Àf×FVÑFVÓBWÐBYÐ$ZØ$0×$7Ñ$7×$AÑ$AÄ#Àf×FVÑFVÓBWÐBYÐ$ZØ$0×$7Ñ$7×$AÑ$AÄ#Àf×FVÑFVÓBWÐBYÐ$Zó("ð &@ó &˜Fð  ŸJ™J¤z°*¼jÈ&Ó'QÔRØŸJ™J¤z°*¼lÈFÓ'SÖTÜ# DÔ*:Ö;àŸ
™
Ô#4°ZÀÈtÏ~É~Ó#^Ö_ðG#`ðJ �
Ø—‘¤<Ó/°H·M±M×4JÑ4JÈ8Ï=É=×KaÑKaÕ4bÜ2°8¸X¿]¹]ÓK�Ø Ÿ™×*Ñ*×4Ñ4�Ø—=‘=×8Ó8ð $Ÿ=™=×>Ñ>ÐJÐJÐJØ#Ÿ=™=×>Ñ>ÐJÐJÐJØ!)§¡×!DÑ!D�JØ!)§¡×!DÑ!D�JØ"Ÿ-™-×,Ñ,×6Ñ6°zÑB�CÜ% cÔ+;Ô<Ð<Ð<Ø"×1Ñ1�HÜ3OØ Ÿ™ z°:ó4Ñ0�H˜h¨ô 4PØŸ™ Z°ó4Ñ0�H˜h¨ð %-´	¼$¸x».È(Ó0SÐ/UÑ$UÐX`Ñ$`�MØ"*¬i¼¸X»ÈÓ.QÐ-SÑ"SÐV^Ñ"^‘Kà"(§+¡+�KØ$,§M¡M�Mô 7:¸%ÀÈmÓ6\ó &^Ñ2�D˜* lÜ! $¬Ô4ð  Ÿ=™=¬MÒ9ØŸJ™JÔ'8¸ÀzÐSW×SaÑSaÓ'bÔcØŸ=™=¬IÓ5ØŸJ™JÜ 1°,À
ÌFÐSW×SaÑSaÓLbÓ cõô $ D¬-Õ8¼ZØ$¤mõ>ð ".×!4Ñ!4˜Ü% j´*Ô=ð &0×%=Ñ%=Ø *× 4Ñ 4´S¸×9IÑ9IÓ5JÐ5LÐ MØ *× 4Ñ 4´S¸×9IÑ9IÓ5JÐ5LÐ MØ *× 4Ñ 4´S¸×9IÑ9IÓ5JÐ5LÐ Mó&˜Fð
  ŸJ™J¤z°,Ä
ÈFÓ'SÔTØŸJ™J¤z°,ÄÈfÓ'UÖVÜ'¨
´MÖBØ%/×%=Ñ%=Ü'1Ø$.×$5Ñ$5×$?Ñ$?ÄÀF×DTÑDTÓ@UÐ@WÐ$XØ$.×$5Ñ$5×$?Ñ$?ÄÀF×DTÑDTÓ@UÐ@WÐ$XØ$.×$5Ñ$5×$?Ñ$?ÄÀF×DTÑDTÓ@UÐ@WÐ$Xó("ð &>ó &˜Fð  ŸJ™J¤z°,Ä
ÈFÓ'SÔTØŸJ™J¤z°,ÄÈfÓ'UÖVÜ# DÔ*:Ö;àŸ
™
Ô#4°\À:ÌzÓ#ZÔ[ØŸ
™
Ô#4°\À:Ì|Ó#\Ö]ðM&^ðN �
à—‘×)Ò)Ø—N‘N¤lÒ2Ü˜Ÿ™×/Ñ/Ó0Ô3EÒEô ÓQ¬x¸¿¹×8OÑ8OÓ/PÔQÔQÜ—M‘M×<Ñ<¸XÀvÐU_ÐT`Ð<Ôaà—‘×'Ñ'×.Ñ.¨xÔ8Ø—
‘
Ø×@Ñ@Ø  (¨O¸Xóôð
 —‘×'Ñ'×+Ñ+Ô-Ø�
à—‘×)Ò)Ø—N‘N¤jÒ0Ü˜Ÿ™×/Ñ/Ó0Ô3EÒEô ÓQ¬x¸¿¹×8OÑ8OÓ/PÔQÔQÜ—M‘M×<Ñ<¸VÀXÐU_ÐT`Ð<Ôaà—‘×'Ñ'×.Ñ.¨xÔ8Ø—
‘
Ø×@Ñ@Ø  (¨H°hóôð
 —‘×'Ñ'×+Ñ+Ô-Ø�
ÙØˆJä�fœgÔ&Ø×)Ñ)¨(¯-©-¸Ó@Ð@ä�vœyÔ)Ü! (Ô,EÔFØ—‘¤,Ò.àŸ™ò �Ü˜d¤JÔ/Ü.¨t¯y©yÓ9�HÜ! (Ô,<Ô=à ä" 8¬XÔ6Ø$ŸM™M×2Ñ2Ð6FÒFððGð $Ÿ=™=¨Ñ+�DÜ& x§}¡}°QÑ'7¸¼|ÓL�Ø—
‘
˜2•ðð ˆJÜ˜¤	Õ*¨t¯~©~ÄÓ/MÜ—|‘|×2Ñ2°6Ó:ˆHÜ# HÓ-ˆFÜ˜f¤jÔ1´jÀÌÔ6RÐRÐRð —‘×)Ò)Ø—N‘N¤lÒ2Ü˜Ÿ™×/Ñ/Ó0Ô3EÒEÜÓU´8¸H¿M¹M×<SÑ<SÓ3TÔUÔUÜ—M‘M×<Ñ<¸XÀvÐU_ÐT`Ð<Ôaà—‘×'Ñ'×.Ñ.¨xÔ8Ø×BÑBØ˜h¨¸ó�ð —‘×'Ñ'×+Ñ+Ô-Ø�
Ü$ X¨x¸¿¹ÓHÐHÜ˜¤Ô,Ø—=’=¨¯©×)>Ñ)>Ô)@Ü(¨°6×3EÑ3EÀtÇ~Á~ÓVÐVØˆIÜ˜¤Ô.Ü$ X¨v×/AÑ/AÀ4Ç>Á>ÓRÐRÜ˜Ô 0Ô1Ü%Ð%àˆIrN   c           
     óª  — g }|j                   j                  D �]6  }t        j                  j	                  ||||¬«      }t        j                  j	                  |||«      }	|�|	€
|dk(  rŒRg c S |r,t        j                  j                  |t        |	«      d¬«      sŒ„|dk(  r|j                   j                  d¬«      rŒ¦|j                  t        |	|| j                  «      «       t        j                  j                  t        j                  j                  ||«      v s�Œ|j                  t        |	|t        | j                  «      «      «       �Œ9 |S )a]  Infer constraints for situations where either 'template' or 'instance' is a protocol.

        The 'protocol' is the one of two that is an instance of protocol type, 'subtype'
        is the type used to bind self during inference. Currently, we just infer constrains for
        every protocol member type (both ways for settable members).
        r7  r0  T)Úignore_pos_arg_names)Úprecise)rx   rA  r´   rÑ   rB  rÒ   r   Úis_metaclassr�   r‚   rª   ÚIS_SETTABLEÚget_member_flagsrP  )
rK   r>  r¥   ÚsubtypeÚprotocolr8  r­   ÚmemberÚinstÚtemps
             rL   rF  z@ConstraintBuilderVisitor.infer_constraints_from_protocol_members  s%  € ð ˆØ—m‘m×4Ñ4ó 	RˆFÜ—=‘=×,Ñ,¨V°X¸wÐR[Ð,Ó\ˆDÜ—=‘=×,Ñ,¨V°X¸wÓGˆDØˆ|˜t˜|Ø˜ZÒ'ØØ’	ñ ô —}‘}×/Ñ/Øœ.¨Ó.ÀTð 0ô ð à˜Ò#¨¯©×(BÑ(BÈ4Ð(BÔ(PØØ�J‰JÔ(¨¨t°T·^±^ÓDÔEÜ�}‰}×(Ñ(¬D¯M©M×,JÑ,JÈ6ÐS[Ó,\Ó\à—
‘
Ô,¨T°4¼ÀÇÁÓ9OÓPÖQð/	Rð0 ˆ
rN   c           
     ót  — |j                  «       j                  «       }d}t        | j                  t        «      �rÇg }| j                  j                  «       j                  «       }|j                  «       }|j                  |j                  }}|j                  �$|j                  �|j                  }|j                  }|j                  �$|j                  �|j                  }|j                  }|j                  t        ||| j                  «      «       |�€Vt        j                  rs|j                  rg| j                  s[t!        d„ |j                  D «       «      r|j"                  s3|j                  t        ||t%        | j                  «      d¬«      «       d}|j"                  �s2t'        |j(                  «      }|�‡|j                  «       sw|j(                  |   }	t        |	t*        «      sJ ‚t-        |	«      }
t/        ||
«      }t/        ||
«      }t1        ||t%        | j                  «      «      }|j                  |«       �n”|j                  t3        ||| j                  «      «       �nl|j4                  }t7        |j(                  «      }|j                  «       }t        j                  rK|j                  r?| j                  s3|j                  t        ||t%        | j                  «      d¬«      «       d}|j9                  |j(                  d | |j:                  d | |j<                  d | ¬«      }|j                  t3        ||| j                  «      «       d }|sœt7        |j:                  D �cg c]  }|t>        t@        fv sŒ|‘Œ c}«      }tC        ||«      }tE        |j(                  |d  |j:                  |d  |j<                  |d  t        j                  s|j                  ng |jF                  ¬«      }n·t7        |j4                  j(                  «      t7        |j4                  j(                  «      k  rx|j9                  tE        |j4                  j(                  |d  |j4                  j:                  |d  |j4                  j<                  |d  |j4                  jF                  ¬«      ¬«      }|�&|jI                  tK        || j                  |«      «       |r&|D ]!  }|xjL                  |j                  z  c_&        Œ# |S t        | j                  tN        «      r»|j                  «       }tO        tP        jR                  | j                  ¬	«      }|€'| jU                  |j(                  | j                  «      }n+tK        |tV        tE        ||gtX        tZ        gd d g«      «      g}|j                  t        |j                  || j                  «      «       |S t        | j                  t\        «      r| j_                  | j                  |«      S t        | j                  t`        «      �r| j                  jb                  }t        |td        «      rtf        jh                  jk                  |«      }t        |tl        «      r”tf        jh                  jo                  |jp                  «      }ts        ||«      }t        |t        «      r+t        |j                  |j                  | j                  «      S t        |t\        «      r| j_                  ||d¬
«      S t        |j                  | j                  jb                  | j                  «      S t        | j                  tl        «      rRtf        jt                  jw                  d| j                  | j                  d¬«      }|rt        ||| j                  «      S g S g S c c}w )NFc              3  óP   K  — | ]  }|j                   j                  «       –— Œ  y ­wrF   )rG   Úis_self)rk   Útvs     rL   rn   z?ConstraintBuilderVisitor.visit_callable_type.<locals>.<genexpr>`  s   è ø€ ÒH°˜BŸE™EŸM™MŸOÑHùs   ‚$&T)r«   )rp   rq   rr   )rp   rq   rr   r…   rs   ro   r9  )Ú
source_any)Úret_onlyr0  r4  )<Úwith_unpacked_kwargsÚwith_normalized_var_argsrW   r’   r   rm   Úret_typeÚ
type_guardÚtype_isr�   r‚   rª   r<   r+  r…   r«   r„   Úis_ellipsis_argsrP  r4   rp   r3   Úget_tuple_fallback_from_unpackÚrepack_callable_argsÚ#build_constraints_for_simple_unpackr,  r-  r   r}   rq   rr   r   r   Úminr!   rs   r|   rB   rJ   r   r)   Úfrom_another_anyr*  r>   r   r   r    Úinfer_against_overloadedr*   rÎ   r%   r´   rµ   ry   r   Útype_object_typerx   r   rÑ   rB  )rK   r¥   rJ   r­   Úcactualrm   Útemplate_ret_typeÚcactual_ret_typeÚunpack_presentÚunpackÚ
tuple_typeÚtemplate_typesr”   Úunpack_constraintsr-  rX  Ú
cactual_psÚcactual_prefixÚparam_spec_targetÚkÚmax_prefix_lenrl   rÝ   rÎ   ÚconstructorrS  s                             rL   Úvisit_callable_typez,ConstraintBuilderVisitor.visit_callable_type<  s‰  € ð ×0Ñ0Ó2×KÑKÓMˆØˆÜ�d—k‘k¤<Õ0Ø$&ˆCØ—k‘k×6Ñ6Ó8×QÑQÓSˆGØ!×,Ñ,Ó.ˆJà2:×2CÑ2CÀW×EUÑEUÐ/ÐØ×"Ñ"Ð.°7×3EÑ3EÐ3QØ$,×$7Ñ$7Ð!Ø#*×#5Ñ#5Ð à×ÑÐ+°·±Ð0KØ$,×$4Ñ$4Ð!Ø#*§?¡?Ð à�J‰JÔ(Ð):Ð<LÈdÏnÉnÓ]Ô^àÑ!ô ×0Ò0Ø×)Ò)Ø ×,Ò,ô ÑH°g×6GÑ6GÔHÔHØ$×5Ò5ð —J‘JÜ)Ø# X¬v°d·n±nÓ/EÐSWôôð
 #'�Kð  ×0Ó0Ü%8¸×9KÑ9KÓ%L�Nð
 &Ð1¸'×:LÑ:LÔ:Nð "*×!3Ñ!3°NÑ!C˜Ü)¨&´*Ô=Ð=Ð=Ü%CÀFÓ%K˜
Ü)=¸hÈ
Ó)S˜Ü';¸GÀZÓ'P˜ä-PØ*¨L¼&ÀÇÁÓ:Pó.Ð*ð Ÿ
™
Ð#5Ö6ð Ÿ
™
Ü@ÀÈ7ÐTX×TbÑTbÓcöð $×*Ñ*�Ü  ×!1Ñ!1Ó2�
Ø$×/Ñ/Ó1�
ä×/Ò/°G×4EÒ4EÈd×N^ÒN^à—J‘JÜ)Ø# X¬v°d·n±nÓ/EÐSWôôð
 #'�Kð ")×!6Ñ!6Ø%×/Ñ/°°Ð<Ø%×/Ñ/°°Ð<Ø%×/Ñ/°°Ð<ð "7ó "�ð
 —
‘
Ü8¸ÀÐQU×Q_ÑQ_Ó`ôð 26Ð!Ù!Ü%(°W×5FÑ5FÖ)b°È!ÔPWÔY`ÐOaÒJaª!Ò)bÓ%c�NÜ!$ Z°Ó!@�JÜ(2Ø")×"3Ñ"3°J°KÐ"@Ø")×"3Ñ"3°J°KÐ"@Ø")×"3Ñ"3°J°KÐ"@Ü;E×;WÒ;W '×"3Ò"3Ð]_Ø,3×,GÑ,Gô)Ñ%ô ˜:×,Ñ,×6Ñ6Ó7¼3¸z×?PÑ?P×?ZÑ?ZÓ;[Ò[Ø,6×,DÑ,DÜ#-Ø*4×*;Ñ*;×*EÑ*EÀjÀkÐ*RØ*4×*;Ñ*;×*EÑ*EÀjÀkÐ*RØ*4×*;Ñ*;×*EÑ*EÀjÀkÐ*RØ4>×4EÑ4E×4YÑ4Yô	$ð -Eó -Ð)ð %Ð0Ø—J‘Jœz¨*°d·n±nÐFWÓXÔYÙØò 7�AØ—M’M W×%6Ñ%6Ñ6–Mð7àˆJÜ˜Ÿ™¤WÔ-Ø!×,Ñ,Ó.ˆJÜœy×9Ñ9ÀdÇkÁkÔRˆHØÐ!à×,Ñ,¨X×-?Ñ-?ÀÇÁÓM‘ô Ø"Ü"Ü" H¨hÐ#7¼(ÄIÐ9NÐQUÐW[ÐP\Ó]óð�ð �J‰JÔ(¨×):Ñ):¸HÀdÇnÁnÓUÔVØˆJÜ˜Ÿ™¤ZÔ0Ø×0Ñ0°·±¸hÓGÐGÜ˜Ÿ™¤XÕ.à—;‘;×#Ñ#ˆDÜ˜$¤	Ô*Ü—|‘|×2Ñ2°4Ó8�Ü˜$¤Ô)Ü"Ÿl™l×;Ñ;¸D¿I¹IÓF�Ü5°kÀ4ÓH�ä˜k¬<Ô8Ü,Ø ×)Ñ)¨;×+?Ñ+?ÀÇÁóð ô   ¬ZÔ8Ø×8Ñ8¸ÀhÐY]Ð8Ó^Ð^Ü$ X×%6Ñ%6¸¿¹×8HÑ8HÈ$Ï.É.ÓYÐYÜ˜Ÿ™¤XÔ.ô —=‘=×,Ñ,Ø˜DŸK™K¨¯©À$ð -ó ˆDñ Ü(¨°4¸¿¹ÓHÐHà�	àˆIùòM *cs   Í1^5Î^5c                ó¢   — t        ||«      }|r+t        |j                  |j                  | j                  «      S t        ||| j                  «      S rF   )Úfind_matching_overload_itemr‚   r�  rª   )rK   Ú
overloadedr¥   r~  rÎ   s        rL   rŠ  z1ConstraintBuilderVisitor.infer_against_overloadedë  sC   € ô +¨:°xÓ@ˆÙÜ$ X×%6Ñ%6¸¿¹ÀtÇ~Á~ÓVÐVÜ  ¨4°·±Ó@Ð@rN   c                ó¬	  — | j                   }t        |j                  «      }t        |t        «      xr |j
                  j                  d«      }t        |t        «      s|�rFg }|��ˆ|�r1|j                  |   }t        |t        «      sJ ‚t        |j
                  «      }t        |t        «      sJ ‚t        ||j
                  j                  d«      «      }t        |t        «      rt        || j                  |¬«      g}nBt        |t        «      r|j
                  j                  dk(  sJ ‚t!        ||| j                  «      }t#        |j                  «      D ]>  \  }	}
|	|k(  rŒ|j%                  t!        |
|j&                  d   | j                  «      «       Œ@ |S t        |t        «      sJ ‚t)        |j                  |j                  | j                  «      }d}d}|j%                  |«       �n¡t        |t        «      �rŽt        |j                  «      }|��K|j                  |   }t        |t        «      sJ ‚t        |j
                  «      }t+        |j                  «      t+        |j                  «      dz   k  râ|}t+        |j                  «      |z
  dz
  }t-        t/        |j                  «      ||«      \  }}}t/        |j                  d | «      }|r|t/        |j                  | d  «      z  }||z   }t        |t        «      rˆ|j
                  j                  dk(  sJ ‚|D ]5  }|j%                  t!        ||j&                  d   | j                  «      «       Œ7 n2d}d}n-t/        |j                  «      }t/        |j                  «      }n|S t        |t        «      sJ ‚t+        |«      t+        |«      k(  r³|j0                  j
                  j2                  rN|j0                  j
                  j2                  r.|t!        |j0                  |j0                  | j                  «      z   S t5        t+        |«      «      D ].  }	|j%                  t!        ||	   ||	   | j                  «      «       Œ0 |j%                  t!        |j0                  |j0                  | j                  «      «       |S t        |t6        «      r| j9                  |j                  |«      S g S )Nri   )rC   rH   rD   r   re   r?   )r’   r4   r~   rW   r   rx   rI  r%   r3   r6   r   Úget_baser-   rB   rª   r€   r‚   rw   r�   rh   r‡  r   r:   Útuplerz   Úis_named_tupleÚranger   r*  )rK   r¥   r’   Úunpack_indexÚis_varlength_tupler­   r“   r•   rV  r�   Útir“  Úactual_itemsÚtemplate_itemsÚa_unpack_indexÚa_unpackÚ
a_unpackedÚa_prefix_lenÚa_suffix_lenrf  rg  rh  Útms                          rL   Úvisit_tuple_typez)ConstraintBuilderVisitor.visit_tuple_typeø  s<  € Ø—‘ˆÜ*¨8¯>©>Ó:ˆä'¨´Ó9ò 
¸f¿k¹k×>RÑ>RØó?
Ðô �fœiÔ(Ò,>Ø$&ˆCØÑ'Ú%ð #+§.¡.°Ñ">�KÜ% k´:Ô>Ð>Ð>Ü$3°K×4DÑ4DÓ$E�MÜ% f¬hÔ7Ð7Ð7Ü6Ø §¡× 4Ñ 4Ð5EÓ Fó�Fô " -Ô1AÔBä&°À$Ç.Á.ÐY_Ô`ð™ô
 ' }´hÔ?Ø -× 2Ñ 2× ;Ñ ;Ð?OÒ OððPô 0°¸vÀtÇ~Á~ÓV˜Ü!*¨8¯>©>Ó!:ò Z™˜˜2Ø Ò,à$àŸ
™
Ô#4°R¸¿¹ÀQ¹ÈÏÉÓ#XÕYðZð �Jä% f¬iÔ8Ð8Ð8Ü)LØ Ÿ™¨¯©°d·n±nó*Ð&ð 68�LØ79�NØ—J‘JÐ1Ö2Ü˜F¤IÕ.Ü!4°V·\±\Ó!B�Ø!Ñ-ð  &Ÿ|™|¨NÑ;�HÜ% h´
Ô;Ð;Ð;Ü!0°·±Ó!?�JÜ˜6Ÿ<™<Ó(¬C°·±Ó,?À!Ñ,CÒCØ'5˜Ü'*¨6¯<©<Ó'8¸>Ñ'IÈAÑ'M˜Ü7SÜ! (§.¡.Ó1°<Àó8Ñ4˜ (¨Hô (-¨V¯\©\¸-¸<Ð-HÓ'I˜Ù'Ø(¬E°&·,±,À¸}¸~Ð2NÓ,OÑO˜LØ)1°HÑ)<˜Ü% j´(Ô;Ø#-§?¡?×#;Ñ#;Ð?OÒ#OÐOÐ#OØ&.ò " Ø #§
¡
Ü$5°b¸*¿/¹/È!Ñ:LÈdÏnÉnÓ$]õ!"ñ"ð
 (*˜Ø)+™ä#(¨¯©Ó#6�LÜ%*¨8¯>©>Ó%:‘Nà�
ô ˜f¤iÔ0Ð0Ð0Ü�<Ó ¤C¨Ó$7Ò7à×+Ñ+×0Ñ0×?Ò?Ø ×1Ñ1×6Ñ6×EÒEð Ô!2Ø ×1Ñ1°6×3JÑ3JÈDÏNÉNó"ñ ð ô œs >Ó2Ó3ò �AØ—J‘JÜ)¨.¸Ñ*;¸\È!¹_ÈdÏnÉnÓ]õðð �J‰JÜ!Ø×-Ñ-¨v×/FÑ/FÈÏÉóôð
 ˆJÜ˜¤Ô(Ø×)Ñ)¨(¯.©.¸&ÓAÐAàˆIrN   c                ó:  — | j                   }t        |t        «      rDg }|j                  |«      D ],  \  }}}|j	                  t        ||| j                  «      «       Œ. |S t        |t        «      r*| j                  |j                  j                  «       |«      S g S rF   )r’   rW   r(   rƒ   r�   r‚   rª   r   r*  r~   rô   )rK   r¥   r’   r­   Ú	item_nameÚtemplate_item_typeÚactual_item_types          rL   Úvisit_typeddict_typez-ConstraintBuilderVisitor.visit_typeddict_typeb  s•   € Ø—‘ˆÜ�fœmÔ,Ø$&ˆCð DLÇ<Á<ÐPVÓCWò dÑ?�	Ð-Ð/?Ø—
‘
Ô,Ð-?ÐAQÐSW×SaÑSaÓbÕcðdàˆJÜ˜¤Ô(Ø×)Ñ)¨(¯.©.×*?Ñ*?Ó*AÀ6ÓJÐJàˆIrN   c                ó   — J d«       ‚)Nz`Unexpected UnionType in ConstraintBuilderVisitor (should have been handled in infer_constraints)re   r  s     rL   Úvisit_union_typez)ConstraintBuilderVisitor.visit_union_typep  r   rN   c                ó   — J d|› �«       ‚)Nz!This should be never called, got re   r  s     rL   Úvisit_type_alias_typez.ConstraintBuilderVisitor.visit_type_alias_typev  s   € ØDÐ9¸(¸ÐDÓDˆurN   c                óÈ  — g }t        |«      D ]Ñ  }t        |t        «      r™t        |j                  t        «      r1|j                  t        |j                  | j                  |«      «       Œ^t        |j                  «      }t        |t        «      sJ ‚|j                  t        ||| j                  «      «       Œ¬|j                  t        ||| j                  «      «       ŒÓ |S rF   )r5   rW   r3   rx   r-   r|   rB   rª   r6   r   r�   r‚   )rK   ÚtypesrÝ   r­   r£   rk  s         rL   r*  z*ConstraintBuilderVisitor.infer_against_anyy  s°   € Ø "ˆô ' uÓ-ò 	KˆAÜ˜!œZÔ(Ü˜aŸf™fÔ&6Ô7Ø—J‘Jœz¨!¯&©&°$·.±.À(ÓKÕLä.¨q¯v©vÓ6�HÜ% h´Ô9Ð9Ð9Ø—J‘JÔ0°¸8ÀTÇ^Á^ÓTÕUð
 —
‘
Ô,¨Q°¸$¿.¹.ÓIÕJð	Kð ˆ
rN   c                óò   — t        | j                  t        «      rt        || j                  «      }n|j                  }g }|D ]2  }|j                  t        || j                  | j                  «      «       Œ4 |S rF   )rW   r’   r   Úfind_matching_overload_itemsr~   r�   r‚   rª   )rK   r¥   r~   r­   r£   s        rL   Úvisit_overloadedz)ConstraintBuilderVisitor.visit_overloadedŒ  sb   € Ü�d—k‘k¤<Ô0Ü0°¸4¿;¹;ÓG‰Eà—N‘NˆEØ "ˆØò 	JˆAØ�J‰JÔ(¨¨D¯K©K¸¿¹ÓHÕIð	Jàˆ
rN   c                óN  — t        | j                  t        «      r¡| j                  j                  «       rR| j                  j	                  «       }| j
                  rt        |«      }t        |j                  || j                  «      S t        |j                  | j                  j                  | j                  «      S t        | j                  t        «      r»| j                  j                  «       r_| j                  j                  d   j	                  «       }| j
                  rt        |«      }t        |j                  || j                  «      S t        |j                  | j                  j                  d   j                  | j                  «      S t        | j                  t        «      r5t        |j                  | j                  j                  | j                  «      S t        | j                  t        «      r+t        |j                  | j                  | j                  «      S g S )Nr   )rW   r’   r   rD  rE  r¬   r   r‚   rÎ   rª   r�  r    r~   r*   r   )rK   r¥   rT  s      rL   Úvisit_type_typez(ConstraintBuilderVisitor.visit_type_type–  sn  € Ü�d—k‘k¤<Ô0Ø�{‰{×&Ñ&Ô(Ø $§¡× =Ñ =Ó ?�Ø×#Ò#Ü$2°=Ó$A�MÜ(¨¯©¸ÀtÇ~Á~ÓVÐVÜ$ X§]¡]°D·K±K×4HÑ4HÈ$Ï.É.ÓYÐYÜ˜Ÿ™¤ZÔ0Ø�{‰{×&Ñ&Ô(Ø $§¡× 1Ñ 1°!Ñ 4× FÑ FÓ H�Ø×#Ò#Ü$2°=Ó$A�MÜ(¨¯©¸ÀtÇ~Á~ÓVÐVÜ$ X§]¡]°D·K±K×4EÑ4EÀaÑ4H×4QÑ4QÐSW×SaÑSaÓbÐbÜ˜Ÿ™¤XÔ.Ü$ X§]¡]°D·K±K×4DÑ4DÀdÇnÁnÓUÐUÜ˜Ÿ™¤WÔ-Ü$ X§]¡]°D·K±KÀÇÁÓPÐPàˆIrN   N)
r’   r$   rª   rZ   r«   r_   r¬   r_   r[   r\   )r¥   r0   r[   úlist[Constraint])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¥   r"   r[   r¿  )r¥   r-   r[   r¿  )r¥   r3   r[   r¿  )r¥   r!   r[   r¿  )r¥   r   r[   r¿  )F)r>  r   r¥   r   rt  r&   ru  r   r8  r_   r[   r¿  )r¥   r   r[   r¿  )r�  r    r¥   r   r~  r_   r[   r¿  )r¥   r%   r[   r¿  )r¥   r(   r[   r¿  )r¥   r2   r[   r¿  )r¥   r'   r[   r¿  )r¹  zIterable[Type]rÝ   r   r[   r¿  )r¥   r    r[   r¿  )r¥   r*   r[   r¿  )r`   ra   rb   rc   rd   rM   r  r  r  r  r  r  r  r  r  r"  r%  r(  r.  rm  rF  rš  rŠ  r®  r³  rµ  r·  r*  r¼  r¾  re   rN   rL   rÂ   rÂ   •  s&  … Ù7ð Óð'Ø ð'Ø-0ð'Ø?Cð'ØRVð'à	ó'ó"óóóóóóó
'ó
óó"óTóó$eðZ	  ð'àð'ð ð'ð ð	'ð
 ð'ð ð'ð 
ó'óRmð` PUðAØ$ðAØ0<ðAØHLðAà	óAóhóTó
óEóó&ôrN   rÂ   c                óZ   — | t         k(  rt        S | t        k(  rt         S t        d| › �«      ‚)z,Map SubtypeOf to SupertypeOf and vice versa.zInvalid operator )r>   r@   Ú
ValueError)rH   s    rL   rP  rP  ­  s3   € ð 
ŒZÒÜÐØ	Œ|Ò	ÜÐäÐ,¨R¨DÐ1Ó2Ð2rN   c                ó²   — | j                   }|D ]B  }t        j                  j                  ||t        j                  j                  dd¬«      sŒ@|c S  |d   S )z.Disambiguate overload item against a template.FT©Ú	is_compatÚis_proper_subtypeÚignore_returnr   )r~   r´   rÑ   Úis_callable_compatiblerÒ   )r�  r¥   r~   rÎ   s       rL   rœ  rœ  ¸  s`   € à×Ñ€EØò 
ˆô �=‰=×/Ñ/ØØÜ—m‘m×.Ñ.Ø#Øð 0õ 
ð ŠKð
ð �‰8€OrN   c                óð   — | j                   }g }|D ]P  }t        j                  j                  ||t        j                  j                  dd¬«      sŒ@|j                  |«       ŒR |s|j                  «       }|S )zMLike find_matching_overload_item, but return all matches, not just the first.FTrÃ  )r~   r´   rÑ   rÇ  rÒ   r|   Úcopy)r�  r¥   r~   r­   rÎ   s        rL   r»  r»  Ë  sz   € ð ×Ñ€EØ
€CØò 
ˆô �=‰=×/Ñ/ØØÜ—m‘m×.Ñ.Ø#Øð 0õ 
ð �J‰J�tÕð
ñ ð �j‰j‹lˆØ€JrN   c                ó€  — t        | j                  «      }t        |t        «      r%|j                  j                  dk(  r|j                  S t        |t
        «      r|j                  j                  S t        |t        «      r8|j                  j                  j                  D ]  }|j                  dk(  sŒ|c S  J d«       ‚)zMGet builtins.tuple type from available types to construct homogeneous tuples.ri   zInvalid unpack type)
r6   rx   rW   r   r€   r-   ry   r%   rz   Úmro)r�  rÌ   Úbases      rL   r…  r…  ã  sœ   € ä	˜Ÿ™Ó	%€BÜ�"”hÔ B§G¡G×$4Ñ$4Ð8HÒ$HØ�w‰wˆÜ�"Ô&Ô'Ø× Ñ ×%Ñ%Ð%Ü�"”iÔ Ø×'Ñ'×,Ñ,×0Ñ0ò 	ˆDØ�}‰}Ð 0Ó0Ø’ð	ð (Ð'Ó'ˆ5rN   c                óà  — t         | j                  vr| j                  S | j                  j                  t         «      }| j                  d| }| j                  |   }g }t	        |t
        «      st        t        ||g«      «      }nbt        |j                  «      }t	        |t        «      r=t	        |j                  d   t
        «      sJ ‚|j                  d   }|j                  dd }||gz   |z   S )ag  Present callable with star unpack in a normalized form.

    Since positional arguments cannot follow star argument, they are packed in a suffix,
    while prefix is represented as individual positional args. We want to put all in a single
    list with unpack in the middle, and prefix/suffix on the sides (as they would appear
    in e.g. a TupleType).
    Nr   r?   )r   rq   rp   ÚindexrW   r3   r   r6   rx   r%   r~   )Úcallabler‘  Ú
star_indexrp   Ú	star_typeÚsuffix_typesrÌ   s          rL   r†  r†  ñ  sÖ   € ô �x×)Ñ)Ñ)Ø×!Ñ!Ð!Ø×#Ñ#×)Ñ)¬(Ó3€JØ×"Ñ" ; JÐ/€IØ×"Ñ" :Ñ.€IØ€LÜ�i¤Ô,äœx¨
°Y°KÓ@ÓA‰	ä˜YŸ^™^Ó,ˆÜ�bœ)Ô$Ü˜bŸh™h q™k¬:Ô6Ð6Ð6ØŸ™ ™ˆIØŸ8™8 A B˜<ˆLØ˜	�{Ñ" \Ñ1Ð1rN   c                óL  — t        | «      }|€J ‚|}t        | «      |z
  dz
  }d}g }t        |«      }|€| |   }||z   t        |«      kD  rdt        |t        «      sJ ‚t        |j                  t
        «      r6t        |j                  |t        g |j                  j                  «      «      gS g S |}	|}
n™|}t        |«      |z
  dz
  }t        ||«      }	t        ||«      }
||k\  r||k\  r| |   }n^||   }t        |t        «      sJ ‚t        |j                  «      }t        |t        «      r"|j                  j                  dk(  r	| |   }|}	|}
t        t        |«      |	|
«      \  }}}t        | d|	 |«      D ]!  \  }}|j!                  t#        |||«      «       Œ# |
r4t        | |
 d |«      D ]!  \  }}|j!                  t#        |||«      «       Œ# |��Rt        |t        «      sJ ‚t        |j                  «      }t        |t        «      rÒ|j                  j                  dk(  r¹|D ]²  }t        |t        «      s*|j!                  t#        |j$                  d   ||«      «       Œ=t        |j                  «      }t        |t        «      sŒc|j                  j                  dk(  sŒ}|j!                  t#        |j$                  d   |j$                  d   |«      «       Œ´ |S t        |t
        «      r9|j'                  t        ||t        t)        |«      |j                  «      «      «       |S )a¯  Infer constraints between two lists of types with variadic items.

    This function is only supposed to be called when a variadic item is present in templates.
    If there is no variadic item the actuals, we simply use split_with_prefix_and_suffix()
    and infer prefix <: prefix, suffix <: suffix, variadic <: middle. If there is a variadic
    item in the actuals we need to be more careful, only common prefix/suffix can generate
    constraints, also we can only infer constraints for variadic template item, if template
    prefix/suffix are shorter that actual ones, otherwise there may be partial overlap
    between variadic items, for example if template prefix is longer:

        templates: T1, T2, Ts, Ts, Ts, ...
        actuals:   A1, As, As, As, ...

    Note: this function can only be called for builtin variadic constructors: Tuple and Callable.
    For instances, you should first find correct type argument mapping.
    Nr?   ri   r   )r4   r   rW   r3   rx   r-   rB   r%   ry   rˆ  r6   r   r€   r:   r   rƒ   r�   r‚   rh   r|   rë   )ri  Úactual_argsrª   Útemplate_unpackÚtemplate_prefixÚtemplate_suffixÚt_unpackr­   Úactual_unpackÚcommon_prefixÚcommon_suffixÚactual_prefixÚactual_suffixÚactual_unpack_typerª  ÚstartÚmiddleÚendr£   r¤   rÌ   Úa_tps                         rL   r‡  r‡    s  € ô& *¨-Ó8€OØÐ&Ð&Ð&Ø%€OÜ˜-Ó(¨?Ñ:¸QÑ>€Oà€HØ
€Cä'¨Ó4€MØÐØ  Ñ1ˆØ˜_Ñ,¬s°;Ó/?Ò?ä˜h¬
Ô3Ð3Ð3Ü˜(Ÿ-™-Ô)9Ô:ô Ø Ÿ™ y´)¸BÀÇÁ×@\Ñ@\Ó2]óðð ð �	Ø'ˆØ'‰à%ˆÜ˜KÓ(¨=Ñ8¸1Ñ<ˆÜ˜O¨]Ó;ˆÜ˜O¨]Ó;ˆØ˜OÒ+°ÀÒ0Pð % _Ñ5‰Hð "-¨]Ñ!;ÐÜÐ0´*Ô=Ð=Ð=Ü(Ð);×)@Ñ)@ÓAˆJÜ˜*¤hÔ/°J·O±O×4LÑ4LÐP`Ò4`Ø(¨Ñ9�à /�Ø /�ô 6ÜˆkÓ˜M¨=óÑ€Eˆ6�3ô �M . =Ð1°5Ó9ò 7‰ˆˆ1Ø�
‰
Ô$ Q¨¨9Ó5Õ6ð7áÜ˜ } n oÐ6¸Ó<ò 	;‰DˆAˆqØ�J‰JÔ(¨¨A¨yÓ9Õ:ð	;ð Ñä˜(¤JÔ/Ð/Ð/Ü˜XŸ]™]Ó+ˆÜ�bœ(Ô#¨¯©×(8Ñ(8Ð<LÒ(Làò [�ä! !¤ZÔ0Ø—J‘JÔ0°·±¸±¸QÀ	ÓJÕKä*¨1¯6©6Ó2�Dä! $¬Õ1°d·i±i×6HÑ6HÐL\Ó6\ØŸ
™
Ô#4°R·W±W¸Q±ZÀÇÁÈ1ÁÈyÓ#YÕZð[ð €Jô ˜Ô,Ô-Ø�J‰J”z " i´¼4À»<È×IZÑIZÓ1[Ó\Ô]Ø€JrN   c                óÈ   — t        | t        t        f«      st        |t        t        f«      rg S |t        k(  rt	        | |t        |«      «      S t	        || t        |«      «      S )zSInfer constraints between two arguments using direction between original callables.)rW   r"   r3   r>   r‚   rP  )ÚleftÚrightrª   s      rL   Úinfer_directed_arg_constraintsræ  j  sY   € ä�$œ¬
Ð3Ô4¼
Ø”œzÐ*ô9ð
 ˆ	Ø”JÒä   u¬f°YÓ.?Ó@Ð@ä  ¨¬f°YÓ.?Ó@Ð@rN   c                óÂ  — g }|t         k(  r| |}}n|| }}|j                  «       }|j                  «       }|j                  «       }|j                  «       }	|�2|�0|j                  t	        |j
                  |j
                  |«      «       |�2|	�0|j                  t	        |j
                  |	j
                  |«      «       |j                  «       D ]U  }
t        j                  j                  ||
«      }|€Œ&|j                  t	        |j
                  |
j
                  |«      «       ŒW |�Ú|j                  d«      }|€J ‚|j                  }|€J ‚|t        |j                  «      k  r�|j                  |   j                  «       r€|j                  |«      }|€J ‚|j                  t	        |j
                  |j
                  |«      «       |dz  }|t        |j                  «      k  r|j                  |   j                  «       rŒ€|	�×|j                   D �ch c]  }|€Œ|’Œ	 }}t#        «       }t%        |j                   |j                  «      D ]-  \  }}|�|j'                  «       s||v rŒ|j)                  |«       Œ/ |j+                  d«      }|€J ‚|D ]G  }|j-                  |«      }|€J ‚|j                  t	        |j
                  |j
                  |«      «       ŒI |S c c}w )aÄ  Infer constraints between argument types of two callables.

    This function essentially extracts four steps from are_parameters_compatible() in
    subtypes.py that involve subtype checks between argument types. We keep the argument
    matching logic, but ignore various strictness flags present there, and checks that
    do not involve subtyping. Then in place of every subtype check we put an infer_constraints()
    call for the same types.
    Nr?   )r>   Úvar_argÚkw_argr�   ræ  ÚtypÚformal_argumentsr´   rµ   Úcallable_corresponding_argumentÚ try_synthesizing_arg_from_varargÚposr   rq   Úis_positionalÚargument_by_positionrr   Úsetrƒ   Úis_starÚaddÚtry_synthesizing_arg_from_kwargÚargument_by_name)r¥   r’   rª   r­   rä  rå  Ú	left_starÚ
left_star2Ú
right_starÚright_star2Ú	right_argÚleft_argÚright_by_positionr�   Úleft_by_positionÚnameÚright_namesÚleft_only_namesÚkindÚright_by_nameÚleft_by_names                        rL   r,  r,  y  s¿  € ð €CØ”JÒØ ˆe‰à˜hˆeˆØ—‘“€IØ—‘“€JØ—‘“€JØ—,‘,“.€Kð Ð Ð!7Ø�
‰
Ô1°)·-±-ÀÇÁÐQZÓ[Ô\ØÐ +Ð"9Ø�
‰
Ô1°*·.±.À+Ç/Á/ÐS\Ó]Ô^ð ×+Ñ+Ó-ò [ˆ	Ü—<‘<×?Ñ?ÀÀiÓPˆØÐØØ�
‰
Ô1°(·,±,À	ÇÁÈyÓYÕZð	[ð ÐØ!×BÑBÀ4ÓHÐØ Ð,Ð,Ð,Ø�N‰NˆØˆ}Ðˆ}Ø”#�d—n‘nÓ%Ò%¨$¯.©.¸Ñ*;×*IÑ*IÔ*KØ#×8Ñ8¸Ó;ÐØ#Ð/Ð/Ð/Ø�J‰JÜ.Ø$×(Ñ(Ð*;×*?Ñ*?Àóôð
 �‰FˆAð ”#�d—n‘nÓ%Ò%¨$¯.©.¸Ñ*;×*IÑ*IÕ*Kð ÐØ(-¯©ÖL ¸4Ñ;K’tÐLˆÐLÜ›%ˆÜ˜dŸn™n¨d¯n©nÓ=ò 	&‰JˆD�$Øˆ|˜tŸ|™|œ~°¸Ñ1DØØ×Ñ Õ%ð	&ð
 ×=Ñ=¸dÓCˆØÐ(Ð(Ð(Ø#ò 	ˆDØ×0Ñ0°Ó6ˆLØÐ+Ð+Ð+Ø�J‰JÜ.¨|×/?Ñ/?À×ARÑARÐT]Ó^õð	ð €Jùò Ms   ÈKÈKc                ó4  — t        «       }| D ]„  }t        |j                  t        «      sŒt        |j                  t        «      s2t        |j                  t
        «      sŒS|j                  j                  rŒj|j                  |j                  «       Œ† g }| D ]}  }t        |j                  t        «      r|j                  |vr|j                  |«       t        |j                  t
        «      r|j                  j                  rŒm|j                  |«       Œ |S )zWFor each ParamSpec remove all imprecise constraints, if at least one precise available.)
rñ  rW   rI   r"   rD   r!   rs   ró  rC   r|   )ÚcsÚhave_preciserl   Únew_css       rL   r†   r†   Â  sÑ   € ä“5€LØò )ˆÜ˜!×+Ñ+¬]Ô;Øä�q—x‘x¤Ô/Ü˜!Ÿ(™(¤JÕ/Ø—H‘H×0Ó0à×Ñ˜QŸZ™ZÕ(ð)ð €FØò ˆÜ˜!×+Ñ+¬]Ô;¸q¿z¹zÐQ]Ñ?]Ø�M‰M˜!ÔÜ˜!Ÿ(™(¤JÔ/°q·x±x×7SÓ7SØ�M‰M˜!Õð	ð
 €MrN   )r‡   r   rp   zSequence[Type | None]rq   zlist[ArgKind]rr   zSequence[str | None] | Nonerˆ   zlist[list[int]]r‰   r=   r[   r¿  )FT)r¥   r&   r’   r&   rª   rZ   r«   r_   r¬   r_   r[   r¿  )rÌ   r$   r[   zTypeGuard[TypeType | UnionType])rÌ   zTypeType | UnionTyper[   r$   )r¥   r&   r’   r&   rª   rZ   r[   úlist[Constraint] | None)rÕ   z!Sequence[list[Constraint] | None]r[   zlist[list[Constraint]])rÜ   rB   r[   rB   )r¥   r2   r’   r&   rª   rZ   r[   r¿  )rÕ   zlist[list[Constraint] | None]r²   r_   r[   r¿  )rÖ   r  r[   r  )r  r¿  r  r¿  r[   r_   )rý   rB   rü   rB   r[   r_   )rH   rZ   r[   rZ   )r�  r    r¥   r   r[   r   )r�  r    r¥   r   r[   zlist[CallableType])r�  r3   r[   r   )rÏ  r   r‘  r   r[   ú
list[Type])ri  r	  rÔ  r	  rª   rZ   r[   r¿  )rä  r&   rå  r&   rª   rZ   r[   r¿  )r¥   ú#NormalizedCallableType | Parametersr’   r
  rª   rZ   r[   r¿  )r  r¿  r[   r¿  )jrc   Ú
__future__r   Úcollections.abcr   r   Útypingr   r   r   r	   Úmypy.subtypesr´   Úmypy.typeopsÚmypy.argmapr
   Úmypy.erasetyper   Úmypy.expandtyper   Úmypy.maptyper   Ú
mypy.nodesr   r   r   r   r   r   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/   r0   r1   r2   r3   r4   r5   r6   r7   r8   r9   r:   Úmypy.types_utilsr;   Úmypy.typestater<   Ú
mypy.inferr=   r>   rd   r@   rB   r    r‚   r¨   r¹   rº   r¿   r×   rÞ   rÀ   r¾   rì   rí   rå   rú   rê   r  rë   rÂ   rP  rœ  r»  r…  r†  r‡  ræ  r,  r†   re   rN   rL   ú<module>r     s�  ðÚ !å "ç .ß 8Ó 8ã Û Ý 'Ý )Ý 3Ý 2÷	÷ 	ó 	÷&÷ &÷ &÷ &÷ &÷ &÷ &÷ &÷ &õ &õN /Ý %áÝ/à€
ˆEÓ Ø€ˆeÓ ÷"añ "aðJfØðfà$ðfð ðfð +ð	fð
 &ðfð "ðfð ófðZ Øð-UØð-Uàð-Uð ð-Uð ð	-Uð
 ð-Uð ó-Uð`jbØðjbØ ðjbØ-0ðjbØ?CðjbØRVðjbàójbóZ
ó]ð:Øð:Ø ð:Ø-0ð:àó:ó2óó
Tó5ópó0Cóó	óKóô(U˜{¨4°
Ñ+;Ñ<ô Uóp3óð&ØðØ&2ðàóó0(ó2ð4\Øð\Ø,6ð\ØCFð\àó\ó~AðFØ1ðFà/ðFð ðFð ó	FôRrN   