
    *e>'                      U d Z ddlmZ ddlmZ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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+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z? dd
l@mAZA ddlBmCZC erddlDmEZE dZFdeGd<   dZHdeGd<    G d d          ZIded!ZJ	 dfdgd*ZKdgd+ZLdhd-ZMdid1ZNdjd3ZOdkd5ZPdld8ZQdmd:ZRdnd=ZSdod@ZTdndAZUdndBZVdpdFZWdqdHZX G dI dJe/eY                   ZZ G dK dLe5eeI                            Z[drdNZ\dsdQZ]dtdSZ^dudWZ_dvdZZ`dwd]Zadxd`ZbdydbZcdzddZddS ){zType inference constraints.    )annotations)TYPE_CHECKINGFinalIterableListSequenceN)ArgTypeExpander)erase_typevars)map_instance_to_supertype)ARG_OPTARG_POSARG_STAR	ARG_STAR2CONTRAVARIANT	COVARIANTArgKindTypeInfo)$TUPLE_LIKE_INSTANCE_NAMESAnyTypeCallableTypeDeletedType
ErasedTypeInstanceLiteralTypeNoneTypeNormalizedCallableType
Overloaded
ParametersParamSpecTypePartialType
ProperType	TupleTypeTypeTypeAliasTypeTypedDictType	TypeOfAny	TypeQueryTypeType	TypeVarIdTypeVarLikeTypeTypeVarTupleTypeTypeVarTypeTypeVisitorUnboundTypeUninhabitedType	UnionType
UnpackTypefind_unpack_in_list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                  L    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	dS )
ConstraintzpA representation of a type constraint.

    It can be either T <: type or T :> type (T is a type variable).
    r)   type_varr   r#   targetr*   opintreturnNonec                V    |j         | _        || _        || _        || _        g | _        d S N)idr@   rB   rA   origin_type_varextra_tvars)selfr@   rB   rA   s       0lib/python3.11/site-packages/mypy/constraints.py__init__zConstraint.__init__P   s3      ' 35    strc                R    d}| j         t          k    rd}| j         d| d| j         S )Nz<:z:> )rB   r=   r@   rA   )rK   op_strs     rL   __repr__zConstraint.__repr__\   s9    7l""F-88&884;888rN   c                D    t          | j        | j        | j        f          S rG   )hashr@   rB   rA   )rK   s    rL   __hash__zConstraint.__hash__b   s    T]DGT[9:::rN   otherobjectboolc                    t          |t                    sdS | j        | j        | j        f|j        |j        |j        fk    S NF)
isinstancer?   r@   rB   rA   )rK   rW   s     rL   __eq__zConstraint.__eq__e   s@    %,, 	5tw4SXS_8```rN   N)r@   r*   rB   rC   rA   r#   rD   rE   )rD   rO   )rD   rC   )rW   rX   rD   rY   )
__name__
__module____qualname____doc____annotations__rB   rM   rS   rV   r]    rN   rL   r?   r?   F   s          
 	
BLLL
5 
5 
5 
59 9 9 9; ; ; ;a a a a a arN   r?   calleer   	arg_typesSequence[Type | None]	arg_kindslist[ArgKind]	arg_namesSequence[str | None] | Noneformal_to_actuallist[list[int]]contextr:   rD   list[Constraint]c                
   g }t          |          }|                                 g }g }	g }
d}t          |          D ]+\  }}|D ]#}|| j        |         t          t
          fv rd} n$,t          |          D ]p\  }}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        |         d          }||         t          k    s"t          t          |          t                    r|                    |           |                    t          |                    |g                               t          |t                    r>|                    t'          |t(          t          ||j                                       t          |t                    rl|j        d         }t          |t                    sJ t          |j
                  }t-          |j                  dz
  }t          |t                    rF|                    t'          |t(          t          |d|          |j                                       nit          |t.                    r|j
        j        d	k    sJ |d|          D ]6}|                    t5          |j        d         |t(                               7|rUt9          |j        dd         || d                   D ].\  }}|                    t5          ||t(                               /@J d            |D ]"}||         }||                    |||         | j        |         | j        |                   }r| j        |         t          t
          fv r|s|                    |                    |||         d||                              ||         }|
                    |t          t
          fvrt:          n|           |	                    |r||         nd           t5          | j        |         |t(                    }|                    |           $rrWt=          fd
|D                       s<|s:|                    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  8   K   | ]}|j         j        k    V  d S rG   )r@   rH   ).0c
param_specs     rL   	<genexpr>z1infer_constraints_for_callable.<locals>.<genexpr>   s,      EEAAJ*-/EEEEEErN   re   rg   ri   imprecise_arg_kindsc              3  @   K   | ]}t          |t                    V  d S rG   )r\   r   )rt   vs     rL   rw   z1infer_constraints_for_callable.<locals>.<genexpr>  s,      
B
BA:a''
B
B
B
B
B
BrN   )"r	   rv   	enumeraterg   r   r   r\   re   r1   r3   typer+   tuple_fallbackr"   partial_fallbackexpand_actual_typeri   appendcopy_modifiedr?   r=   itemslenr   fullnameextendinfer_constraintsrq   zipr   anyr   	variablesfilter_imprecise_kinds)rd   re   rg   ri   rk   rm   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_typeactual_kindru   rv   s                                @rL   infer_constraints_for_callabler   k   sW    %'KW%%F""$$J# 011  
7 	 	F~&"21"5(I9N"N"N +/' 011 o* o*
7f&q):66 n	* *1-Kk:66666
 L+K,<==M-)9:: N!.!=M955 N!.!?MMMMM!  "+F"3"*"(";";#f%$Q'$Q'!% #< # # V$00J#O44i5 50 !''8888 !''">#?#?oEV#?#W#WXX    -)9:: *N""%$!,0LMM     M955 "N  -215!,
;;;;;&5l6G&H&H# !4559
13CDD &&"/(% ,\zk\ :<O<^      ##6AA/4=AQQQQQ*<ZK<8  #**-.A.Fq.I2|\\     T"%m&9!""&=|ZKLL?Y"Z"Z T TB#**+<R\+R+RSSSSMMMMM! * *"+F"3"*$77#Yv%68H8KVM]^_M`   *&"21"5(I9N"N"N
 3 
^,33"55 /61BD)TZJ[   
 '0&7,33'28Y:O'O'OGGU`   -334\If4E4EX\]]])&*:1*={LYYA&&q))))5*8 	
EEEEEEEEE
 (
 	222(,	  	 		
 	
 	
 
B
B1A
B
B
BBB :,[99rN   Ftemplater#   r   	directionrC   skip_neg_oprY   c                    t           fdt          t          j                  D                       rg S t	                     s"t          t                     t                    rdt                     sg S t          j        	                     f           t           ||          }t          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   | ]G\  }}t                    t          |          k    ot                    t          |          k    V  Hd S rG   )r3   )rt   tar   r   s      rL   rw   z$infer_constraints.<locals>.<genexpr>*  so         Q 	!!_Q%7%77 	:F##q'9'99     rN   )r   reversedr9   	inferringr4   r\   r3   r   r5   r   _infer_constraintspop)r   r   r   r   ress   ``   rL   r   r     s    2       z344     
 	8$$ 	
?83L3Lh(W(W 	 X&& 	I##Xv$6777 69kJJ  """
h	;GGGrN   c                     }t                      t                    t           t                    r&t          j                             j        d           t          t                    r&t          j                            j        d          t          t                    rj        t          j
        k    rg S t           t                    rt                     gS t          t                    rkj                                        sRt          k    rGt           t                    rt!          d  j        D                       st          j                  t$          k    rGt           t                    r2g } j        D ]&}|                    t)          |                     '|S t          k    rGt          t                    r2g }j        D ]&}|                    t)          ||                     '|S t$          k    rGt          t                    r2t+          j                  }t-           fd|D             d          S t          k    rmt           t                    rXt-          fd j        D             d          }	|	r|	S t/                     r t/                    st1                     S g S                      t5          |                    S )NT)keep_erasedc              3  @   K   | ]}t          |t                    V  d S rG   r\   r,   rt   r   s     rL   rw   z%_infer_constraints.<locals>.<genexpr>d  s=       :
 :
+,Jq+&&:
 :
 :
 :
 :
 :
rN   c                2    g | ]}t          |          S rc   infer_constraints_if_possible)rt   a_itemr   r   s     rL   
<listcomp>z&_infer_constraints.<locals>.<listcomp>  s&    \\\F*8VYGG\\\rN   eagerc                2    g | ]}t          |          S rc   r   )rt   t_itemr   r   s     rL   r   z&_infer_constraints.<locals>.<listcomp>  s5        .ffiHH  rN   F)r3   r\   r0   mypytypeopsmake_simplified_unionr   r   type_of_anyr&   suggestion_enginer,   r?   rH   is_meta_varr=   r   upper_boundr;   r   r   simplify_away_incomplete_typesany_constraintsr4   handle_recursive_unionacceptConstraintBuilderVisitor)
r   r   r   r   orig_templater   r   r   r   results
   ```       rL   r   r   =  sI    Mx((HV$$F
 (I&& X<55hnRV5WW&)$$ T33FLd3SS &'"" v'9Y=X'X'X	 (K(( 98Y7788 	6;''
9	%%''
9 %% (I.. 	9c :
 :
08:
 :
 :
 7
 7
 	9 %V%788F
 J:h	#B#Bn 	E 	EFJJ(CCDDDD
L  Z	%B%B l 	L 	LFJJ(	JJKKKK
 J:fi#@#@.v|<< \\\\\V[\\\
 
 
 	
 L  Z)%D%D  !    &n   
 
 
  	GM ** 	G3Fv3N3N 	G)(FIFFF	 ??3FI{SSTTTrN   list[Constraint] | Nonec                   |t           k    r/t          j                            t	          |           |          sdS |t
          k    r/t          j                            |t	          |                     sdS |t
          k    rIt          | t                    r4t          j                            |t	          | j                            sdS 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=   r\   r,   r   r   )r   r   r   s      rL   r   r     s     Jt}'?'?x@X@XZ`'a'atL  )A)Ax((* *  t\!!x-- 	"((@T1U1UVV 	" tXvy999rN   options!Sequence[list[Constraint] | None]list[list[Constraint]]c                v    g }| D ]3}|t          d |D                       r|                    |           4|S )zDSelect only those lists where each item is a constraint against Any.Nc              3  d   K   | ]+}t          t          |j                  t                    V  ,d S rG   )r\   r3   rA   r   rt   ru   s     rL   rw   z!select_trivial.<locals>.<genexpr>  s6      NN!z/!(33W==NNNNNNrN   )allr   )r   r   options      rL   select_trivialr     sU    
C  >NNvNNNNN 	JJvJrN   
constraintc           	         | 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.)rA   r8   r   r&   implementation_artifactr?   rI   rB   r0   
make_unionlinecolumn)r   rA   any_types      rL   merge_with_anyr     sh    F   y899H"fh/fmLL  rN   r0   c                    d | j         D             }d | j         D             }t          t          j        |          ||          p"t          t          j        |          ||          S )Nc                <    g | ]}t          |t                    |S rc   r   r   s     rL   r   z*handle_recursive_union.<locals>.<listcomp>  s'    VVV:a;U;UV!VVVrN   c                <    g | ]}t          |t                    |S rc   r   r   s     rL   r   z*handle_recursive_union.<locals>.<listcomp>  s'    NNNA:a3M3MNaNNNrN   )r   r   r0   r   )r   r   r   non_type_var_itemstype_var_itemss        rL   r   r     sv     WVX^VVVNNNNNN/00&)  T	9/??	S	STrN   list[list[Constraint] | None]r   c                ^   |rd | D             nd | D             sg S t                    dk    rd         S t          fddd         D                       rd         S t          fddd         D                       rt                    }|rot          |          t                    k     rOg }D ]-}||v r|d |D             }nd}|                    |           .t	          t          |          |          S d	 | D             }|| k    rt	          ||
          S g S )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.
    c                    g | ]}||S rc   rc   rt   r   s     rL   r   z#any_constraints.<locals>.<listcomp>  s    @@@F@@@@rN   c                    g | ]}||S rG   rc   r   s     rL   r   z#any_constraints.<locals>.<listcomp>  s    LLLF9K9K9K9KrN   r<   r   c              3  D   K   | ]}t          d          |          V  dS r   N)is_same_constraintsrt   ru   valid_optionss     rL   rw   z"any_constraints.<locals>.<genexpr>  s3      
O
O}Q/33
O
O
O
O
O
OrN   Nc              3  D   K   | ]}t          d          |          V  dS r   )is_similar_constraintsr   s     rL   rw   z"any_constraints.<locals>.<genexpr>  s3      
R
R1!-"2A66
R
R
R
R
R
RrN   c                ,    g | ]}t          |          S rc   )r   r   s     rL   r   z#any_constraints.<locals>.<listcomp>  s!    =`=`=`TUnQ>O>O=`=`=`rN   c                ,    g | ]}t          |          S rc   )filter_satisfiable)rt   os     rL   r   z#any_constraints.<locals>.<listcomp>  s!    ???!*1--???rN   r   )r   r   r   r   r   list)r   r   trivial_optionsmerged_optionsr   merged_optionfiltered_optionsr   s          @rL   r   r     s     M@@g@@@LLgLLL 	
=QQ

O
O
O
O]122=N
O
O
OOO  Q

R
R
R
Rabb@Q
R
R
RRR @
 )77 
	@s?33c-6H6HHHN' 5 5_,,%=`=`Y_=`=`=`MM$(M%%m4444"4#7#7??? @?w???7""/u==== IrN   r   c                p   | s| S g }| D ]t          j        t                    rGj        j        r;t	          fdj        j        D                       r|                               ct          j                            j	        j        j
                  r|                               |sdS |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  b   K   | ])}t           j                            j        |          V  *d S rG   )r   r   r   rA   )rt   valueru   s     rL   rw   z%filter_satisfiable.<locals>.<genexpr>  sH        >C((599     rN   N)r\   rI   r,   valuesr   r   r   r   r   rA   r   )r   satisfiableru   s     @rL   r   r     s      K " "a'55 	"!:K:R 	"    GHGXG_     & ""1%%%]%%ah0A0MNN 	"q!!! trN   xyc                    | D ] t          fd|D                       s dS !|D ] t          fd| D                       s dS !dS )Nc              3  8   K   | ]}t          |          V  d S rG   is_same_constraintrt   c2c1s     rL   rw   z&is_same_constraints.<locals>.<genexpr>'  .      ::"%b"--::::::rN   Fc              3  8   K   | ]}t          |          V  d S rG   r  r  s     rL   rw   z&is_same_constraints.<locals>.<genexpr>*  r  rN   T)r   )r   r   r  s     @rL   r   r   %  s      ::::::::: 	55	  ::::::::: 	55	4rN   r  r  c                6   t          t          | j                  t                    o&t          t          |j                  t                    }| j        |j        k    o;| j        |j        k    p|o)t          j                            | j        |j                  S rG   )	r\   r3   rA   r   r@   rB   r   r   is_same_type)r  r  skip_op_checks      rL   r  r  /  s    ry997CC 
	""GI IM 	r{" 	=Ube^,}	=M&&ry")<<rN   c                B    t          | |          o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   ;  s$     #1a((J-DQ-J-JJrN   c                   | D ]}d}|D ]v}t          t          |j                  t                    p&t          t          |j                  t                    }|j        |j        k    r|j        |j        k    s|rd} nw|s dS dS )zCheck that every constraint in the first list has a similar one in the second.

    See docstring above for definition of similarity.
    FT)r\   r3   rA   r   r@   rB   )r   r   r  has_similarr  r  s         rL   r  r  E  s    
    	 	B&ry'A'A7KK z	**GP PM {bk))ru~~~" 	55	4rN   typesIterable[Type]
list[Type]c                @    d | D             }|r|S t          |           S )Nc                0    g | ]}t          |          |S rc   )is_complete_type)rt   typs     rL   r   z2simplify_away_incomplete_types.<locals>.<listcomp>Z  s&    >>>(8(=(=>>>>rN   )r   )r  completes     rL   r   r   Y  s.    >>u>>>H E{{rN   r  c                D    |                      t                                S )zIs a type complete?

    A complete doesn't have uninhabited type components or (when not in strict
    optional mode) None components.
    )r   CompleteTypeVisitor)r  s    rL   r  r  a  s     ::)++,,,rN   c                  (     e Zd Zd fdZd	dZ xZS )
r  rD   rE   c                T    t                                          t                     d S rG   )superrM   r   )rK   	__class__s    rL   rM   zCompleteTypeVisitor.__init__k  s!    rN   r   r/   rY   c                    dS r[   rc   )rK   r   s     rL   visit_uninhabited_typez*CompleteTypeVisitor.visit_uninhabited_typen  s    urN   )rD   rE   )r   r/   rD   rY   )r^   r_   r`   rM   r   __classcell__)r  s   @rL   r  r  j  sQ                    rN   r  c                      e Zd ZU dZded<   dEd
ZdFdZdGdZdHdZdIdZ	dJdZ
dKdZdLdZdMdZdNdZdOd ZdPd"ZdQd$ZdRd&ZdSd(Z	 dTdUd/ZdVd1ZdWd4ZdXd6ZdYd8ZdZd:Zd[d<Zd\d@Zd]dAZd^dCZdDS )_r   z-Visitor class for inferring type constraints.r!   r   r   rC   r   rY   rD   rE   c                0    || _         || _        || _        d S rG   )r   r   r   )rK   r   r   r   s       rL   rM   z!ConstraintBuilderVisitor.__init__y  s     " 'rN   r   r.   rn   c                    g S rG   rc   rK   r   s     rL   visit_unbound_typez+ConstraintBuilderVisitor.visit_unbound_type      	rN   r   c                    g S rG   rc   r%  s     rL   	visit_anyz"ConstraintBuilderVisitor.visit_any  r'  rN   r   c                    g S rG   rc   r%  s     rL   visit_none_typez(ConstraintBuilderVisitor.visit_none_type  r'  rN   r/   c                    g S rG   rc   r%  s     rL   r   z/ConstraintBuilderVisitor.visit_uninhabited_type  r'  rN   r   c                    g S rG   rc   r%  s     rL   visit_erased_typez*ConstraintBuilderVisitor.visit_erased_type  r'  rN   r   c                    g S rG   rc   r%  s     rL   visit_deleted_typez+ConstraintBuilderVisitor.visit_deleted_type  r'  rN   r   c                    g S rG   rc   r%  s     rL   visit_literal_typez+ConstraintBuilderVisitor.visit_literal_type  r'  rN   r    c                    J d            )NFzInternal errorrc   r%  s     rL   visit_partial_typez+ConstraintBuilderVisitor.visit_partial_type  s    &&&&&rN   r,   c                    J d            )NFzbUnexpected TypeVarType in ConstraintBuilderVisitor (should have been handled in infer_constraints)rc   r%  s     rL   visit_type_varz'ConstraintBuilderVisitor.visit_type_var      	
?	
 	
 	
rN   r   c                    g S rG   rc   r%  s     rL   visit_param_specz)ConstraintBuilderVisitor.visit_param_spec  s    	rN   r+   c                    t           rG   )NotImplementedErrorr%  s     rL   visit_type_var_tuplez-ConstraintBuilderVisitor.visit_type_var_tuple  s    !!rN   r1   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SSrN   r   c                   t          | j        t                    r |                     |j        | j                  S t
          j        r5t          | j        t                    rt          || j        | j	                  S t          d          )Nz#Parameters cannot be constrained to)r\   r   r   infer_against_anyre   r9   infer_polymorphicr   $infer_callable_arguments_constraintsr   r>  r%  s     rL   visit_parametersz)ConstraintBuilderVisitor.visit_parameters  s{     dk7++ 	K))(*<dkJJJ' 	_Jt{J,O,O 	_ 8$+t~^^^@AAArN   r   c                   & | j         x}}g }t          |t          t          f          rj        j        rdj        j        v rt          fdj        j        D                       sj        j        	                               t          j                            d|d          }|J t          j                            |t          |                    r+t          ||| j                  }|                    |           j        j                                         t          |t                    r|j        |                                rj        j        rt+          |j                  }t          |t.                    rt          j                            |          }t          |t4                    rB| j        t6          k    r}n|}|                    |                     ||d                     |j        }t          |t:                    rj        j        rt          |j        t4                    rL| j        t6          k    r}n|j        }|                    |                     |j        |d                     | j        t>          k    r|j        }	t          |	t@                    rt+          |	j!                  }	t          |	t4                    rA|	j        j"        r5|                    |                     |	j        j"        |                     t          |t                    r|j        |j        }t          |tF                    r|$                                j        }t          |tJ                    r|j        }t          |t4                    
r|&t                    }
t          |
t4                    sJ | j        t6          k    rDj        &                    &j        j'                  rtQ          &j                  }|j        j)        j*        }&j        j+        r&j        j,        J &j        j-        J &j        j,        }&j        j-        }&j        j)        j*        |         }t          |t\                    sJ |j        }t_          &j0        ||          \  }}}t_          |j0        ||          \  }}}|t/          tc          |          |          fz   |z   }|t/          tc          |          |          fz   |z   }n|j0        }&j0        }te          |||          D ]\  }}}t          |t@                    r|j3        th          k    r)|                    t          ||| j                             |j3        tj          k    r6|                    t          ||tm          | j                                       t          |tn                    rt          |tn                    r|j8        }t          |tr                    r|:                    |j;        ty          |j;                  d          |j=        ty          |j=                  d          |j>        ty          |j>                  d                    }|	                    t          |t6          |                     |	                    t          |t>          |                     t          |tn                    r|:                    ts          |j8        j;        ty          |j;                  d          |j8        j=        ty          |j=                  d          |j8        j>        ty          |j>                  d                              }|	                    t          |t6          |                     |	                    t          |t>          |                     t          |t\                    r)|                    t          ||| j                             |S | j        t>          k    rD&j        &                    j        j'                  rtQ          &j                  }j        j)        j*        }j        j+        rj        j,        J j        j-        J j        j,        }j        j-        }j        j)        j*        |         }t          |t\                    sJ |j        }t_          j0        ||          \  }}} t_          |j0        ||          \  }}}|t/          tc          |          |          fz   | z   }!|t/          tc          |          |          fz   |z   }n|j0        }j0        }!te          |||!          D ]\  }}}"t          |t@                    r|j3        th          k    r)|                    t          |"|| j                             |j3        tj          k    r6|                    t          |"|tm          | j                                       t          |tn                    rt          |"tn                    r|"j8        }t          |tr                    r|:                    |j;        ty          |j;                  d          |j=        ty          |j=                  d          |j>        ty          |j>                  d                    }|	                    t          |"t6          |                     |	                    t          |"t>          |                     t          |tn                    r|:                    ts          |j8        j;        ty          |j;                  d          |j8        j=        ty          |j=                  d          |j8        j>        ty          |j>                  d                              }|	                    t          |"t6          |                     |	                    t          |"t>          |                     t          |t\                    r)|                    t          |"|| j                             |S j        j        r| j        t>          k    rt          fdt          j        j                  D                       st          j        A                    &|
dg          rjj        j        	                               |                    |                     &|                     j        j                                         |S &j        j        r| j        t6          k    rt          &fd	t          &j        j                  D                       st          j        A                    |
&dg          rj&j        j        	                    &           |                    |                     &&                     &j        j                                         |S |r|S t          |t                    r| C                    j0        |          S t          |t.                    rt          t                    r| j        t>          k    r|jF        D ]}#t          |#t                    r^t+          |#j                  }$t          |$t\                    rAt          |$t4                    r|$j        j'        d
k    sJ |$j0        d         }#t          j0        d         |#t>                    }%|                    |%           |S t          |t.                    rC| j        t>          k    r3t          t          j                            |          | j                  S t          |t@                    r=|jH        s4|jI        J                                st          |j!        | j                  S g S t          |tn                    rt          |j!        | j                  S t          |t\                    rt          g S )N__call__c              3  $   K   | ]
}|k    V  d S rG   rc   rt   r   r   s     rL   rw   z:ConstraintBuilderVisitor.visit_instance.<locals>.<genexpr>  s'      JJQ8q=JJJJJJrN   Tis_operator	class_objprefixc              3  $   K   | ]
}|k    V  d S rG   rc   rH  s     rL   rw   z:ConstraintBuilderVisitor.visit_instance.<locals>.<genexpr>  '      QQ!AQQQQQQrN   )skipc              3  $   K   | ]
}|k    V  d S rG   rc   )rt   r   instances     rL   rw   z:ConstraintBuilderVisitor.visit_instance.<locals>.<genexpr>  rP  rN   rr   r   )Lr   r\   r   r   r}   is_protocolprotocol_membersr   r   r   r   r   find_memberr   r
   r   r   r   r   fallbackis_type_objr3   ret_typer"   r   r~   r   r;   'infer_constraints_from_protocol_membersr(   itemr=   r,   r   metaclass_typer%   as_anonymousr   has_baser   r   defn	type_varshas_type_var_tuple_typetype_var_tuple_prefixtype_var_tuple_suffixr+   r7   rq   r   r   variancer   r   neg_opr   rN  r   r   re   r   rg   ri   r?   r   is_protocol_implementationr   rA  r6   r   r   r1   r   rH   r   r;  )'rK   r   original_actualr   r   callsubresrY  subtyper   erasedmappedtvars
prefix_lenr   tvtrW  i_prefixi_middlei_suffixm_prefixm_middlem_suffixinstance_argsmapped_argstvar
mapped_arginstance_argrN  suffixt_prefixt_middlet_suffixtemplate_argstemplate_argr[  unpackedcbrS  s'    `                                    @rL   visit_instancez'ConstraintBuilderVisitor.visit_instance  s_   #';.& "f|Z899 	2hm>W 	2X];;;JJJJ(-2IJJJJJ 	2M+228<<<=44"Hf$ 5  D  +++}//t8L8LMM +!24!P!P

6***M+//111fl++ 	%0K!!## (A *6?;;h	22 E#|::8DDHh11 	~33"*"*JJDD$hT E    
 _Ffh'' 	HM,E 	&+x00 	>Z//&GG$kG

@@XwD A    
 ~--fk22 A,V-?@@Ffh// FK4N JJDD"K6&(    fj)) 	%fo.I_Ffm,, 	4((**3Ffk** 	%_Ffh'' o	H#H--Ffh///// ~++0F0Fx}G]0^0^+28X]KK(2=8 2 $=>JJJ#=>JJJ!)!DJ!)!DJ"-,6zBC%c+;<<<<<"1H3O z:4 40Hh 4PZ4 40Hh %-	$x..(0S0S/U$UX`$`M"*iX.Q.Q-S"SV^"^KK"(+K$,MM 7:%m6\6\ #` #`2D*l!$44 "`  =M99JJ'8\SWSa'b'bccc=I55JJ 1*lFSWSaLbLb c c   $D-88 `Z
Ta=b=b `!+!2%lJ?? U ,8+E+E , 6s6;K7L7L7N7N O , 6s6;K7L7L7N7N O , 6s6;K7L7L7N7N O, ,F
  JJz*j&'Q'QRRRJJz*lF'S'STTTT'mDD 	U%1%?%?'1$0$7$A#fFVBWBWBYBY$Z$0$7$A#fFVBWBWBYBY$Z$0$7$A#fFVBWBWBYBY$Z(" (" &@ & &F  JJz*j&'Q'QRRRJJz*lF'S'STTT#D*:;; `

#4Zt~#^#^___
<//HM4J4J8=Ka4b4b/28X]KK *4=8 2 $=>JJJ#=>JJJ!)!DJ!)!DJ"-,6zBC%c+;<<<<<"1H3O z:4 40Hh 4PZ4 40Hh %-	$x..(0S0S/U$UX`$`M"*iX.Q.Q-S"SV^"^KK"(+K$,MM 7:%m6\6\ %` %`2D*l!$44 $`  =M99JJ'8zSWSa'b'bccc=I55JJ 1,
FSWSaLbLb c c   $D-88 `Z$m> > ` ".!4%j*== W &0%=%= * 4S9I5J5J5L5L M * 4S9I5J5J5L5L M * 4S9I5J5J5L5L M& &F
  JJz,
F'S'STTTJJz,f'U'UVVVV'
MBB 	W%/%=%='1$.$5$?FDT@U@U@W@W$X$.$5$?FDT@U@U@W@W$X$.$5$?FDT@U@U@W@W$X(" (" &> & &F  JJz,
F'S'STTTJJz,f'U'UVVV#D*:;; `

#4\:t~#^#^___
)&Nl22 QQQQx8O/P/PQQQQQ 3 M<<XvU_T`<aa 3 '..x888

@@ (OX   
 '++---
)Nj00 QQQQx8O/P/PQQQQQ 1 M<<VXU_T`<aa	 1 '..x888

@@ (Hh   
 '++---
 	Jfg&& 	A))(-@@@vy))	!(,EFF	 ,..  dJ// 	,.ty99H!(,<== ! "8X66$M26FFFFF#=+D&x}Q'7|LL

2J	** 	t~/M/M$Xt|/J/J6/R/RTXTbccc,, 		= W)>)>)@)@ W(63Et~VVVI.. 	$Xv/A4>RRR 011 	%%IrN   FrS  rj  r#   protocolrL  c           
        g }|j         j        D ]}t          j                            ||||          }t          j                            |||          }	||	|dk    rQg c S |                    t          |	|| j                             t          j        j        t          j        	                    ||          v r6|                    t          |	|t          | j                                       |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).
        rK  NrF  )r}   rU  r   r   rV  r   r   r   IS_SETTABLEget_member_flagsre  )
rK   rS  r   rj  r  rL  r   memberinsttemps
             rL   rZ  z@ConstraintBuilderVisitor.infer_constraints_from_protocol_members  s     m4 	R 	RF=,,VXwR[,\\D=,,VXwGGD|t|Z''			 JJ(tT^DDEEE}(DM,J,J6S[,\,\\\

,T49O9OPPQQQ
rN   r   c           
        |                                 }d}t          | j        t                    r!g }| j                                         }|                                }|j        |j        }}|j        |j        }|j        |j        }|                    t          ||| j	                             |Gt          j        rf|j        r_| j        sXt          d |j        D                       s:|                    t          ||t          | j	                  d                     d}|j        st#          |j                  }||j        |         }	t          |	t&                    sJ t)          |	          }
t+          ||
          }t+          ||
          }t-          ||t          | j	                            }|                    |           nb|                    t/          ||| j	                             n7|j        }t3          |j                  }|                                }t          j        rH|j        rA| j        s:|                    t          ||t          | j	                  d                     d}|                    |j        d |         |j        d |         |j        d |                   }|                    t/          ||| j	                             d }|st3          d |j        D                       }t;          ||          }t=          |j        |d          |j        |d          |j        |d          t          j        s|j        ng |j                  }nt3          |j        j                  t3          |j        j                  k    rg|                    t=          |j        j        |d          |j        j        |d          |j        j        |d          |j        j                  	          }|)|                     tC          || j	        |                     |r|D ]}|xj"        |j        z  c_"        |S t          | j        tF                    r|                                }tG          tH          j%        | j        
          }|!| &                    |j        | j                  }n6tC          |tN          t=          ||gtP          tR          gd d g                    g}|                    t          |j        || j	                             |S t          | j        tT                    r| +                    | j        |          S t          | j        tX                    r%t          |j        | j        j-        | j	                  S t          | j        t\                    rGt^          j0        1                    d| j        | j        d          }|rt          ||| j	                  S g S g S )NFc              3  6   K   | ]}|j         j        d k    V  dS r   )rH   raw_id)rt   tvs     rL   rw   z?ConstraintBuilderVisitor.visit_callable_type.<locals>.<genexpr>  s+      NNb 1NNNNNNrN   T)r   )re   rg   ri   c                2    g | ]}|t           t          fv |S rc   )r   r   )rt   ks     rL   r   z@ConstraintBuilderVisitor.visit_callable_type.<locals>.<listcomp>J  s)    )b)b)b!PWY`OaJaJa!JaJaJarN   )re   rg   ri   r   ry   rx   rM  )
source_anyrF  rI  )2with_unpacked_kwargsr\   r   r   rv   rY  
type_guardr   r   r   r9   rB  r   r   r   re  is_ellipsis_argsr2   re   r1   get_tuple_fallback_from_unpackrepack_callable_args#build_constraints_for_simple_unpackrC  rN  r   r   rg   ri   minr   ry   r   r?   rJ   r   r&   from_another_anyrA  r;   r   r   r   infer_against_overloadedr(   r[  r   r   r   rV  )rK   r   rJ   r   cactualrv   template_ret_typecactual_ret_typeunpack_presentunpack
tuple_typetemplate_typesr   unpack_constraintsrN  rn  
cactual_pscactual_prefixparam_spec_targetmax_prefix_lenru   r   rh  s                          rL   visit_callable_typez,ConstraintBuilderVisitor.visit_callable_type  s2    0022dk<00 L	$&Ck6688G!,,..J2:2CWEU/".$,$7!!-#*#5 JJ():<Ldn]]^^^! 0')' !,'  NNG<MNNNNN' JJ)#Xvdn/E/ESW    
 #'K  0 %89K%L%LN%1 "*!3N!C)&*=====%CF%K%K
)=h
)S)S';GZ'P'P-P*L&:P:P. .* 

#56666 

@7TXTbcc   $* !122
$//11
/ 'G4E 'dN^ 'JJ)#Xvdn/E/ESW    
 #'K ")!6!6%/<%/<%/< "7 " "
 

8QUQ_``   26!! %()b)bW5F)b)b)b%c%cN!$Z!@!@J(2")"3JKK"@")"3JKK"@")"3JKK"@;E;W"_'"3"3]_,3,G) ) )%% :,6773z?P?Z;[;[[[,6,D,D#-*4*;*Ejkk*R*4*;*Ejkk*R*4*;*Ejkk*R4>4E4Y	$ $ $ -E - -) %0JJz*dnFWXXYYY 7 7 7AMMW%66MMMJW-- 	!,,..Jy9dkRRRH!,,X-?MM """Hh#7(I9NQUW[P\]]  JJ():HdnUUVVVJZ00 	00hGGGX.. 	$X%68H$.YYYX.. 	 =,,DK$ -  D  (4HHH	IrN   
overloadedr   c                N    t          ||          }t          ||| j                  S rG   )find_matching_overload_itemr   r   )rK   r  r   r[  s       rL   r  z1ConstraintBuilderVisitor.infer_against_overloaded  s'     +:x@@ 4@@@rN   r"   c                   | j         }t          |j                  }t          |t                    o|j        j        dk    }t          |t                    s|rg }|f|r|j        |         }t          |t                    sJ t          |j                  }t          |t                    rt          || j        |          g}n=t          |t                    r|j        j        dk    sJ t          ||| j                  }t          |t                    sJ t          |j                  D ]@\  }}	||k    r|                    t          |	|j        d         | j                             A|S t          |t                    sJ t#          |j        |j        | j                  }
d}d}|                    |
           nt          |t                    rt          |j                  }|Q|j        |         }t          |t                    sJ t          |j                  }t%          |j                  dz   t%          |j                  k    r|}t%          |j                  |z
  dz
  }t'          t)          |j                  ||          \  }}}t)          |j        d |                   }|r |t)          |j        | d                    z  }||z   }t          |t                    rK|j        j        dk    sJ |D ]6}|                    t          ||j        d         | j                             7n0d}d}n+t)          |j                  }t)          |j                  }n|S t          |t                    sJ t%          |          t%          |          k    r|j        j        j        r4|j        j        j        r#|t          |j        |j        | j                  z   S t/          t%          |                    D ]7}|                    t          ||         ||         | j                             8|S t          |t0                    r|                     |j        |          S g S )Nrr   )r@   rB   rA   r   rc   r<   )r   r2   r   r\   r   r}   r   r"   r1   r3   r+   r?   r   r   r|   r   rq   r  r   r7   tupler   is_named_tupleranger   rA  )rK   r   r   unpack_indexis_varlength_tupler   r   r   r   tir  actual_itemstemplate_itemsa_unpack_indexa_unpack
a_unpackeda_prefix_lena_suffix_lenr|  r}  r~  tms                         rL   visit_tuple_typez)ConstraintBuilderVisitor.visit_tuple_type  s   *8>::vx((UV[-AEU-U 	 fi(( X	,> X	$&C'% 3 #+.">K%k:>>>>>$3K4D$E$EM!-1ABB 	W&$.Y_```
 '}h?? - 2 ;?O O O O O/vt~VV%fh77777!*8>!:!: Z Z2,,$

#4RQ#X#XYYYYJ%fi88888)L dn* *& 68L79NJJ12222FI..  !4V\!B!B!-  &|N;H%h
;;;;;!0!?!?J6<((1,HN0C0CCC'5'*6<'8'8>'IA'M7S!(.11<8 84(H (-V\-<--H'I'I' P(E&,}~~2N,O,OOL)1H)<%j(;; "#-?#;?O#O#O#O#O&. " " #

$5b*/!:Ldn$]$]!" !" !" !" (*)+#(#6#6L%*8>%:%:NN
 fi00000<  C$7$777+0? 16E
 !2 163JDN" "   s>2233  AJJ).*;\!_dn]]    J(( 	))(.&AAAIrN   r%   c                T   | j         }t          |t                    rIg }|                    |          D ]/\  }}}|                    t          ||| j                             0|S t          |t                    r-|                     |j	        
                                |          S g S rG   )r   r\   r%   r   r   r   r   r   rA  r   r   )rK   r   r   r   	item_nametemplate_item_typeactual_item_types          rL   visit_typeddict_typez-ConstraintBuilderVisitor.visit_typeddict_type  s    fm,, 
	$&C DL<<PVCWCW d d?	-/?

,-?AQSWSabbccccJ(( 	))(.*?*?*A*A6JJJIrN   r0   c                    J d            )NFz`Unexpected UnionType in ConstraintBuilderVisitor (should have been handled in infer_constraints)rc   r%  s     rL   visit_union_typez)ConstraintBuilderVisitor.visit_union_type  r7  rN   r$   c                    J d|             )NFz!This should be never called, got rc   r%  s     rL   visit_type_alias_typez.ConstraintBuilderVisitor.visit_type_alias_type  s    DD(DDDDDrN   r  r  r   c                   g }|D ]}t          |t                    rt          |j        t                    r/|                    t          |j        | j        |                     `t          |j                  }t          |t                    sJ |	                    t          ||| j                             |	                    t          ||| j                             |S rG   )r\   r1   r}   r+   r   r?   r   r3   r   r   r   )rK   r  r   r   r   r  s         rL   rA  z*ConstraintBuilderVisitor.infer_against_any  s     " 	K 	KA!Z(( Kaf&677 VJJz!&$.(KKLLLL.qv66H%h99999JJ08T^TTUUUU
 

,Q$.IIJJJJ
rN   c                    t          | j        t                    rt          || j                  }n|j        }g }|D ]0}|                    t          || j        | j                             1|S rG   )r\   r   r   find_matching_overload_itemsr   r   r   r   )rK   r   r   r   r   s        rL   visit_overloadedz)ConstraintBuilderVisitor.visit_overloaded  sq    dk<00 	#04;GGEENE " 	J 	JAJJ(DKHHIIII
rN   r(   c                
   t          | j        t                    r%t          |j        | j        j        | j                  S t          | j        t                    r0t          |j        | j        j        d         j        | j                  S t          | j        t                    r%t          |j        | j        j        | j                  S t          | j        t                    r t          |j        | j        | j                  S g S )Nr   )r\   r   r   r   r[  rY  r   r   r   r(   r   r%  s     rL   visit_type_typez(ConstraintBuilderVisitor.visit_type_type"  s    dk<00 		$X]DK4H$.YYYZ00 	$X]DK4Ea4H4QSWSabbbX.. 	$X]DK4DdnUUUW-- 	$X]DKPPPIrN   N)r   r!   r   rC   r   rY   rD   rE   )r   r.   rD   rn   )r   r   rD   rn   )r   r   rD   rn   )r   r/   rD   rn   )r   r   rD   rn   )r   r   rD   rn   )r   r   rD   rn   )r   r    rD   rn   )r   r,   rD   rn   )r   r   rD   rn   )r   r+   rD   rn   )r   r1   rD   rn   )r   r   rD   rn   )r   r   rD   rn   F)rS  r   r   r   rj  r#   r  r   rL  rY   rD   rn   )r   r   rD   rn   )r  r   r   r   rD   rn   )r   r"   rD   rn   )r   r%   rD   rn   )r   r0   rD   rn   )r   r$   rD   rn   )r  r  r   r   rD   rn   )r   r   rD   rn   )r   r(   rD   rn   )r^   r_   r`   ra   rb   rM   r&  r)  r+  r   r.  r0  r2  r4  r6  r9  r<  r?  rD  r  rZ  r  r  r  r  r  r  rA  r  r  rc   rN   rL   r   r   r  sG        77 ' ' ' '                     
' ' ' '
 
 
 
   " " " "T T T T	B 	B 	B 	BP P P Pp      <T T T Tl	A 	A 	A 	A_ _ _ _B   
 
 
 
E E E E   "   
 
 
 
 
 
rN   r   rB   c                n    | 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)rB   s    rL   re  re  /  s=     
Z	|		1R11222rN   r  r   c                    | j         }|D ]9}t          j                            ||t          j        j        dd          r|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  :  si    E 
 
 =//m.# 0 
 
 	 KKK	 8OrN   list[CallableType]c                    | j         }g }|D ]J}t          j                            ||t          j        j        dd          r|                    |           K|s|                                }|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  M  s     E
C 
 
 =//m.# 0 
 
 	 JJt  jjllJrN   r  r1   r   c                H   t          | j                  }t          |t                    r|j        j        dk    r|j        S t          |t
                    r|j        j        S t          |t                    r#|j        j        j	        D ]}|j        dk    r|c S J d            )zMGet builtins.tuple type from available types to construct homogeneous tuples.rr   FzInvalid unpack type)
r3   r}   r\   r   r   r+   r~   r"   r   mro)r  tpbases      rL   r  r  e  s    		%	%B"h BG$48H$H$Hw"&'' & %%"i   ',0 	 	D} 000 1'''''rN   callabler  c                   t           | j        vr| j        S | j                            t                     }| j        d|         }| j        |         }g }t	          |t
                    st          t          ||g                    }ngt          |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   rg   re   indexr\   r1   r   r3   r}   r"   r   )r  r  
star_indexre   	star_typesuffix_typesr  s          rL   r  r  s  s     x)))!!#))(33J";J;/I":.ILi,, (x
YK@@AA		Y^,,b)$$ 	(bhqk:66666I8ABB<L	{"\11rN   r  actual_argsc                &   t          |           }|J |}t          |           |z
  dz
  }d}g }t          |          }|| |         }||z   t          |          k    rbt          |t                    sJ t          |j        t
                    r/t          |j        |t          g |j        j                            gS g S |}	|}
nK|}t          |          |z
  dz
  }t          ||          }	t          ||          }
||k    r||k    r| |         }t          t          |          |	|
          \  }}}t          | d|	         |          D ])\  }}|                    t          |||                     *|
rCt          | |
 d         |          D ])\  }}|                    t          |||                     *|it          |t                    sJ t          |j                  }t          |t                     r|j        j        dk    r|D ]}t          |t                    s0|                    t          |j        d         ||                     Gt          |j                  }t          |t                     rJ|j        j        dk    r:|                    t          |j        d         |j        d         |                     nFt          |t
                    rD|                    t          ||t          t)          |          |j                                       n|||         }t          |t                    sJ t          |j                  }t          |t                     r|j        j        dk    r| |         }t          |t                    sJ t          |j                  }t          |t                     rJ|j        j        dk    r:|                    t          |j        d         |j        d         |                     |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<   rr   r   )r2   r   r\   r1   r}   r+   r?   r"   r~   r  r7   r  r   r   r   r3   r   r   rq   r   r   )r  r  r   template_unpacktemplate_prefixtemplate_suffixt_unpackr   actual_unpackcommon_prefixcommon_suffixactual_prefixactual_suffixstartmiddleendr   r   r  a_tpactual_unpack_typer  s                         rL   r  r    s,   & *-88O&&&%O-((?:Q>OH
C'44M 1_,s;/?/???h
33333(-)9::   y)B@\2]2]   	''%K((=81<O];;O];;O++0P0P %_5H 6kM= E63 M.=.1599 7 71

$Q9556666 ;}noo6<< 	; 	;DAqJJ(Ay99::::(J/////X]++b(## 	^(8<L(L(L [ [!!Z00 [JJ0Q	JJKKKK*1622D!$11 [di6HL\6\6\

#4RWQZ1y#Y#YZZZ[ ,-- 	^JJz"i4<<IZ1[1[\\]]]		" )7,j99999$%7%<==
j(++ 	Y
0HL\0\0\$_5Hh
33333 //B"h'' YBG,<@P,P,P

,RWQZ9KYWWXXXJrN   leftrightc                   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.)r\   r   r1   r;   r   re  )r  r  r   s      rL   infer_directed_arg_constraintsr    sz    $
344 
z*9 9 
 	J ufY.?.?@@@ fY.?.?@@@rN   #NormalizedCallableType | Parametersc                   g }|t           k    r| |}}n|| }}|                                }|                                }|                                }|                                }	|0|.|                    t	          |j        |j        |                     |0|	.|                    t	          |j        |	j        |                     |                                D ]S}
t          j        	                    ||
          }|%|                    t	          |j        |
j        |                     T||
                    d          }|J |j        }|J |t          |j                  k     r|j        |                                         r|                    |          }|J |                    t	          |j        |j        |                     |dz  }|t          |j                  k     r|j        |                                         |	d |j        D             }t#                      }t%          |j        |j                  D ]5\  }}||                                s||v r |                    |           6|                    d          }|J |D ]I}|                    |          }|J |                    t	          |j        |j        |                     J|S )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<   c                    h | ]}||S rG   rc   )rt   names     rL   	<setcomp>z7infer_callable_arguments_constraints.<locals>.<setcomp>3  s    LLL4;Kt;K;K;KrN   )r;   var_argkw_argr   r  r  formal_argumentsr   r   callable_corresponding_argument try_synthesizing_arg_from_varargposr   rg   is_positionalargument_by_positionri   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right_namesleft_only_namesr  kindright_by_nameleft_by_names                        rL   rC  rC    s    CJeheIJJ,,..K !7

1)-QZ[[\\\+"9

1*.+/S\]]^^^ ++-- [ [	<??iPP

1(,	yYYZZZZ !BB4HH ,,,N}}}#dn%%%%$.*;*I*I*K*K%#88;;#///JJ.$(*;*?   
 FA #dn%%%%$.*;*I*I*K*K% LLLLL%%dndn== 	& 	&JD$|t||~~|1D1D%%%%==dCC(((# 	 	D0066L+++JJ.|/?ART]^^    JrN   csc                
   t                      }| D ]w}t          |j        t                    st          |j        t                    s&t          |j        t
                    r&|j        j        s|                    |j                   xg }| D ]u}t          |j        t                    r	|j        |vr|	                    |           t          |j        t
                    r|j        j        s|	                    |           v|S )zWFor each ParamSpec remove all imprecise constraints, if at least one precise available.)
r  r\   rI   r   rA   r   ry   r  r@   r   )r  have_preciseru   new_css       rL   r   r   E  s   55L ) )!+];; 	qx//	)!(J//	) H0	)
 QZ(((F  !+];; 	qzQ]?]?]MM!!(J// 	qx7S 	MM!MrN   )rd   r   re   rf   rg   rh   ri   rj   rk   rl   rm   r:   rD   rn   r  )
r   r#   r   r#   r   rC   r   rY   rD   rn   )r   r#   r   r#   r   rC   rD   r   )r   r   rD   r   )r   r?   rD   r?   )r   r0   r   r#   r   rC   rD   rn   )r   r   r   rY   rD   rn   )r   r   rD   r   )r   rn   r   rn   rD   rY   )r  r?   r  r?   rD   rY   )r  r  rD   r  )r  r#   rD   rY   )rB   rC   rD   rC   )r  r   r   r   rD   r   )r  r   r   r   rD   r  )r  r1   rD   r   )r  r   r  r   rD   r  )r  r  r  r  r   rC   rD   rn   )r  r#   r  r#   r   rC   rD   rn   )r   r  r   r  r   rC   rD   rn   )r  rn   rD   rn   )era   
__future__r   typingr   r   r   r   r   mypy.subtypesr   mypy.typeopsmypy.argmapr	   mypy.erasetyper
   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-   r.   r/   r0   r1   r2   r3   r4   r5   r6   r7   mypy.types_utilsr8   mypy.typestater9   
mypy.inferr:   r;   rb   r=   r?   r   r   r   r   r   r   r   r   r   r   r  r   r  r   r  rY   r  r   re  r  r  r  r  r  r  rC  r   rc   rN   rL   <module>r#     s   ! ! ! " " " " " " A A A A A A A A A A A A A A         ' ' ' ' ' ' ) ) ) ) ) ) 2 2 2 2 2 2	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	% % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % %L / . . . . . % % % % % % 0//////
        "a "a "a "a "a "a "a "aJc c c cN GL)H )H )H )H )HXZU ZU ZU ZUz: : : :2      
T 
T 
T 
T1 1 1 1h   .   	 	 	 	K K K K   (   - - - -    )D/   z
 z
 z
 z
 z
{4
+;< z
 z
 z
z3 3 3 3   &   0( ( ( (2 2 2 24] ] ] ]@A A A AF F F FR     rN   