o
    ØÝ2g•  ã                   @  s   d Z ddlmZ ddlmZmZ ddlZddlm	Z	 ddl
mZ ddlmZmZmZmZ ddlmZ dd	lmZmZmZmZmZmZ dd
lmZ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: G dd„ dƒZ;dKdd„Z<dLdd„Z=e	dMdNdd„ƒZ>edMdOdd„ƒZ>dMdOdd„Z>G dd„ de2e' ƒZ?dPd!d"„Z@dQd$d%„ZAdRd'd(„ZBdSd,d-„ZCdTd/d0„ZDdUd1d2„ZEdVd3d4„ZFdVd5d6„ZGdUd7d8„ZHdWd;d<„ZIdXd?d@„ZJdYdBdC„ZKdZdFdG„ZLd[dIdJ„ZMdS )\z3Calculation of the least upper bound types (joins).é    )Úannotations)ÚSequenceÚoverloadN)Úexpand_type)Úmap_instance_to_supertype)ÚCONTRAVARIANTÚ	COVARIANTÚ	INVARIANTÚVARIANCE_NOT_READY)Ústate)ÚSubtypeContextÚfind_memberÚis_equivalentÚis_proper_subtypeÚis_protocol_implementationÚ
is_subtype) ÚAnyTypeÚCallableTypeÚDeletedTypeÚ
ErasedTypeÚFunctionLikeÚInstanceÚLiteralTypeÚNoneTypeÚ
OverloadedÚ
ParametersÚParamSpecTypeÚPartialTypeÚ
ProperTypeÚ	TupleTypeÚTypeÚTypeAliasTypeÚTypedDictTypeÚ	TypeOfAnyÚTypeTypeÚ	TypeVarIdÚTypeVarLikeTypeÚTypeVarTupleTypeÚTypeVarTypeÚTypeVisitorÚUnboundTypeÚUninhabitedTypeÚ	UnionTypeÚ
UnpackTypeÚfind_unpack_in_listÚget_proper_typeÚget_proper_typesÚsplit_with_prefix_and_suffixc                   @  s*   e Zd Zddd„Zdd	d
„Zddd„ZdS )ÚInstanceJoinerÚreturnÚNonec                 C  s
   g | _ d S ©N)Úseen_instances)Úself© r8   úA/home/garg/my-data/venv/lib/python3.10/site-packages/mypy/join.pyÚ__init__9   ó   
zInstanceJoiner.__init__Útr   Úsr   c                 C  sJ  ||f| j v s||f| j v rt|ƒS | j  ||f¡ |j|jkrg }|jjr}|jjd us/J ‚|jjd us7J ‚|jj}|jj}|jjj| }t	|t
ƒsMJ ‚|j}t|j||ƒ\}}	}
t|j||ƒ\}}}|tt|	ƒ|ƒf |
 }|tt|ƒ|ƒf | }n|j}|j}t|||jjjƒD ]í\}}}t|ƒ}t|ƒ}d }t	|tƒr§ttj|ƒ}nÆt	|tƒr³ttj|ƒ}nºt	|tƒr)|jttfv rït||| ƒ}t|jƒdkrÝ||jvrÝ| j  ¡  t|ƒ  S t||jƒsî| j  ¡  t|ƒ  S n~|jtt fv r(t	|t!ƒr|j"r|}nit	|t!ƒr|j"r|}n\t#||ƒs"| j  ¡  t|ƒ  S t||| ƒ}nDt	|t
ƒrZtt||| ƒƒ}t	|t$ƒrK|jj%dksFJ ‚t&|ƒ}n"t	|tƒsSJ ‚| '|j(¡ qŒt#||ƒsgt|jƒ  S t||| ƒ}|d ustJ ‚| |¡ qŒt$|j|ƒ}n|jj)r˜t*||t+dddr˜|  ,||¡}n|  ,||¡}| j  ¡  |S )Nr   úbuiltins.tupleT)Úignore_type_params)Úsubtype_context)-r6   Úobject_from_instanceÚappendÚtypeÚhas_type_var_tuple_typeÚtype_var_tuple_prefixÚtype_var_tuple_suffixÚdefnÚ	type_varsÚ
isinstancer'   Útuple_fallbackr1   Úargsr   ÚlistÚzipr/   r   r#   Úfrom_another_anyr(   Úvariancer   r
   Ú
join_typesÚlenÚvaluesÚpopr   Úupper_boundr	   r   r+   Ú	ambiguousr   r   Úfullnamer-   ÚextendÚitemsÚbasesr   r   Újoin_instances_via_supertype)r7   r<   r=   rK   ÚprefixÚsuffixÚtvtÚfallbackÚs_prefixÚs_middleÚs_suffixÚt_prefixÚt_middleÚt_suffixÚs_argsÚt_argsÚtaÚsaÚtype_varÚ	ta_properÚ	sa_properÚnew_typeÚresultr8   r8   r9   Újoin_instances<   sˆ   



þ
€
ÿ
zInstanceJoiner.join_instancesc           	      C  sÒ   |j jD ]}t||ƒrt||| ƒ  S q|j jD ]}t||ƒr't||| ƒ  S qd }|j jD ]}t||j ƒ}|  ||¡}|d u sEt||ƒrG|}q.|d usNJ ‚|j jD ]}t|t	ƒrf|  ||¡}t||ƒrf|}qR|S r5   )
rC   Ú_promoter   rP   rY   r   rn   Ú	is_betterrI   r   )	r7   r<   r=   ÚpÚbestÚbaseÚmappedÚresÚpromoter8   r8   r9   rZ      s.   
ÿ
ÿ€

€z+InstanceJoiner.join_instances_via_supertypeN)r3   r4   )r<   r   r=   r   r3   r   )Ú__name__Ú
__module__Ú__qualname__r:   rn   rZ   r8   r8   r8   r9   r2   8   s    

ar2   ÚdeclarationúType | Noner=   r    r<   r3   r   c                 C  s2  t | ƒ} t |ƒ}t |ƒ}|j|jf|j|jfkr$tj |¡}tj |¡}t|tƒr+|S t|tƒr2|S t	||ddr;|S t	||ddrD|S t| t
ƒrQtj ||g¡S t|tƒr`t|tƒs`||}}t|tƒrot|tƒso||}}t||ƒ\}}t|t
ƒr…t|t
ƒs…||}}| t|ƒ¡}| du s•t|| ƒr—|S | S )zµReturn a simple least upper bound given the declared type.

    This function should be only used by binder, and should not recurse.
    For all other uses, use `join_types()`.
    T)Úignore_promotionsN)r/   Úcan_be_trueÚcan_be_falseÚmypyÚtypeopsÚtrue_or_falserI   r   r   r   r,   Úmake_simplified_unionr   r+   Únormalize_callablesÚacceptÚTypeJoinVisitorr   )rz   r=   r<   Úvaluer8   r8   r9   Újoin_simple¹   s6   





r‡   c                 C  s(   t | |ƒr|S t || ƒr| S tt|ƒƒS )zQReturn one of types (expanded) if it is a supertype of other, otherwise top type.)r   Úobject_or_any_from_typer/   ©r=   r<   r8   r8   r9   Útrivial_joinê   s
   

rŠ   Úinstance_joinerúInstanceJoiner | Nonec                 C  ó   d S r5   r8   ©r=   r<   r‹   r8   r8   r9   rP   ô   s   rP   c                 C  r   r5   r8   rŽ   r8   r8   r9   rP   ú   ó   c                 C  sì   t j | |¡rt| |ƒS t| ƒ} t|ƒ}| j| jf|j|jfkr,t j | ¡} t j |¡}t| t	ƒr;t|t	ƒs;|| } }t| t
ƒrB| S t| tƒrI|S t| tƒrXt|tƒsX|| } }t| tƒrgt|tƒsg|| } }t| |ƒ\} }| t| |ƒ¡S )zkReturn the least upper bound of s and t.

    For example, the join of 'int' and 'object' is 'object'.
    )r   r€   Úis_recursive_pairrŠ   r/   r}   r~   r   rI   r,   r   r   r   r+   rƒ   r„   r…   rŽ   r8   r8   r9   rP   þ   s&   





c                   @  s  e Zd ZdZdRdSd	d
„ZdTdd„ZdUdd„ZdVdd„ZdWdd„ZdXdd„Z	dYdd„Z
dZdd „Zd[d"d#„Zd\d%d&„Zd]d(d)„Zd^d+d,„Zd_d.d/„Zd`d1d2„Zdad4d5„Zdbd7d8„Zdcd;d<„Zddd=d>„Zded@dA„ZdfdCdD„ZdgdFdG„ZdhdIdJ„ZdidLdM„ZdjdPdQ„ZdS )kr…   zpImplementation of the least upper bound algorithm.

    Attributes:
      s: The other (left) type operand.
    Nr=   r   r‹   rŒ   r3   r4   c                 C  s   || _ || _d S r5   )r=   r‹   )r7   r=   r‹   r8   r8   r9   r:   ,  s   
zTypeJoinVisitor.__init__r<   r*   c                 C  s
   t tjƒS r5   )r   r#   Úspecial_form©r7   r<   r8   r8   r9   Úvisit_unbound_type0  r;   z"TypeJoinVisitor.visit_unbound_typer,   c                 C  s"   t | j|ƒr|S tj | j|g¡S r5   )r   r=   r   r€   r‚   r’   r8   r8   r9   Úvisit_union_type3  s   z TypeJoinVisitor.visit_union_typer   c                 C  s   |S r5   r8   r’   r8   r8   r9   Ú	visit_any9  r   zTypeJoinVisitor.visit_anyr   c                 C  sH   t jr!t| jttfƒr|S t| jtƒrttj	ƒS t
j | j|g¡S | jS r5   )r   Ústrict_optionalrI   r=   r   r+   r*   r   r#   r‘   r   r€   r‚   r’   r8   r8   r9   Úvisit_none_type<  s   
zTypeJoinVisitor.visit_none_typer+   c                 C  ó   | j S r5   ©r=   r’   r8   r8   r9   Úvisit_uninhabited_typeG  ó   z&TypeJoinVisitor.visit_uninhabited_typer   c                 C  r˜   r5   r™   r’   r8   r8   r9   Úvisit_deleted_typeJ  r›   z"TypeJoinVisitor.visit_deleted_typer   c                 C  r˜   r5   r™   r’   r8   r8   r9   Úvisit_erased_typeM  r›   z!TypeJoinVisitor.visit_erased_typer(   c                 C  s,   t | jtƒr| jj|jkr| jS |  | j¡S r5   )rI   r=   r(   ÚidÚdefaultr’   r8   r8   r9   Úvisit_type_varP  s   zTypeJoinVisitor.visit_type_varr   c                 C  ó   | j |kr|S |  | j ¡S r5   ©r=   rŸ   r’   r8   r8   r9   Úvisit_param_specV  ó   
z TypeJoinVisitor.visit_param_specr'   c                 C  r¡   r5   r¢   r’   r8   r8   r9   Úvisit_type_var_tuple[  r¤   z$TypeJoinVisitor.visit_type_var_tupler-   c                 C  s   t ‚r5   )ÚNotImplementedErrorr’   r8   r8   r9   Úvisit_unpack_type`  r   z!TypeJoinVisitor.visit_unpack_typer   c                   sv   t | jtƒr5t|jƒt| jjƒkr|  | j¡S ddlm‰  |j‡ fdd„t	| jj|jƒD ƒt
| j|ƒdS |  | j¡S )Nr   ©Ú
meet_typesc                   s   g | ]	\}}ˆ ||ƒ‘qS r8   r8   )Ú.0Ús_aÚt_ar¨   r8   r9   Ú
<listcomp>j  s    ÿz4TypeJoinVisitor.visit_parameters.<locals>.<listcomp>)Ú	arg_typesÚ	arg_names)rI   r=   r   rQ   r®   rŸ   Ú	mypy.meetr©   Úcopy_modifiedrM   Úcombine_arg_namesr’   r8   r¨   r9   Úvisit_parametersc  s   
ÿ
üz TypeJoinVisitor.visit_parametersr   c                 C  s$  t | jtƒr?| jd u rtƒ | _| j || j¡}d }|jjr&t| j|ƒr&|}n| jjjr4t|| jƒr4| j}|r;t	||ƒr=|S |S t | jt
ƒr\|jjrUt|ƒ}|rUt|| jƒS t|| jjƒS t | jtƒrht|| jƒS t | jtƒrtt|| jƒS t | jtƒr€t|| jƒS t | jtƒrŒt|| jƒS |  | j¡S r5   )rI   r=   r   r‹   r2   rn   rC   Úis_protocolr   rp   r   Úunpack_callback_protocolrP   r^   r$   r"   r   r   rŸ   )r7   r<   ÚnominalÚ
structuralÚcallr8   r8   r9   Úvisit_instancer  s6   
zTypeJoinVisitor.visit_instancer   c                 C  sè   t | jtƒrJt|| jƒrJt|| jƒrt|| jƒS t|| jƒ}| ¡ r'| ¡ j	s5| j ¡ r2| j ¡ j	s5d|_
tdd„ t|jƒD ƒƒrHt|j| jƒS |S t | jtƒrVt|| jƒS t | jtƒrm| jjjrmt| jƒ}|rmt||ƒS t|j| jƒS )NTc                 s  s    | ]
}t |ttfƒV  qd S r5   )rI   r   r+   )rª   Útpr8   r8   r9   Ú	<genexpr>Ÿ  s
   € ÿ
ÿz6TypeJoinVisitor.visit_callable_type.<locals>.<genexpr>)rI   r=   r   Úis_similar_callablesr   Úcombine_similar_callablesÚjoin_similar_callablesÚis_type_objÚtype_objectÚis_abstractÚfrom_type_typeÚanyr0   r®   rP   r^   r   r   rC   r´   rµ   )r7   r<   rm   r¸   r8   r8   r9   Úvisit_callable_type“  s2   ÿÿþ
þþ

z#TypeJoinVisitor.visit_callable_typer   c                 C  sÈ   g }| j }t|tƒrJ|jD ]%}|jD ]}t||ƒr1t||ƒr'| t||ƒ¡ qt||ƒr1| |¡ qq|rCt	|ƒdkr?|d S t
|ƒS t|j|jƒS t|tƒr^|jjr^t|ƒ}|r^t||ƒS t|j|ƒS )Né   r   )r=   rI   r   rX   r¼   r   rB   r½   r   rQ   r   rP   r^   r   rC   r´   rµ   )r7   r<   rm   r=   Út_itemÚs_itemr¸   r8   r8   r9   Úvisit_overloaded¯  s,   






€û
z TypeJoinVisitor.visit_overloadedr   úlist[Type] | Nonec                   s2  t |jƒ‰ t |jƒ‰ˆ du r7ˆdu r7| ¡ | ¡ kr5g }t| ¡ ƒD ]}| t|j| |j| ƒ¡ q"|S dS ˆ durqˆdurq|jˆ  }t|tƒsMJ ‚t|j	ƒ}|jˆ }t|tƒs^J ‚t|j	ƒ}| ¡ | ¡ kr	ˆ ˆkr	ˆ}	| ¡ ˆ d }
g }t
|jd|	… |jd|	… ƒD ]\}}| t||ƒ¡ qŒt||ƒ}t|tƒr«| t|ƒ¡ n;t|tƒr¾|j	jdkr¾| t|ƒ¡ n(t|tƒrÎ|j	jdksËJ ‚|}n
t|tƒsÕJ ‚|j}| t|jt|ƒgdƒ¡ |
rt
|j|
 d… |j|
 d… ƒD ]\}}| t||ƒ¡ qú|S | ¡ dks| ¡ dkrot|tƒr#t|tƒs%dS |j	jdks.J ‚|j	jdks7J ‚t|jd |jd ƒ}‡fdd„t|jƒD ƒ}‡ fdd„t|jƒD ƒ}t|| ƒ}t||ƒ}t|j|gdƒgS dS ˆ dur}|}ˆ }|}nˆdus„J ‚|}ˆ}|}|j| }t|tƒs—J ‚t|j	ƒ}t|tƒs¤dS | ¡ | ¡ d k r±dS |}	| ¡ |	 d }
tt|jƒ|	|
ƒ\}}}g }t
||jd|	… ƒD ]\}}| t||ƒ¡ qÓtt|ƒƒ}t||jd ƒ}| t|j|gdƒ¡ |
rt
||j|
 d… ƒD ]\}}| t||ƒ¡ q	|S )	a<  Join two tuple types while handling variadic entries.

        This is surprisingly tricky, and we don't handle some tricky corner cases.
        Most of the trickiness comes from the variadic tuple items like *tuple[X, ...]
        since they can have arbitrary partial overlaps (while *Ts can't be split).
        NrÅ   r>   )rK   r   c                   ó   g | ]
\}}|ˆ kr|‘qS r8   r8   ©rª   ÚiÚa)Út_unpack_indexr8   r9   r­   %  ó    z/TypeJoinVisitor.join_tuples.<locals>.<listcomp>c                   rÊ   r8   r8   rË   )Ús_unpack_indexr8   r9   r­   &  rÏ   )r.   rX   ÚlengthÚrangerB   rP   rI   r-   r/   rC   rM   r'   r   rV   rJ   r±   rA   rK   Ú	enumerateÚjoin_type_listr1   ÚtuplerL   )r7   r=   r<   rX   rÌ   Ús_unpackÚ
s_unpackedÚt_unpackÚ
t_unpackedÚ
prefix_lenÚ
suffix_lenÚsiÚtiÚjoinedÚtuple_instanceÚ
mid_joinedÚt_otherÚs_otherÚother_joinedÚvariadicÚunpack_indexÚfixedÚunpackÚunpackedr[   Úmiddler\   ÚfiÚvir8   )rÐ   rÎ   r9   Újoin_tuplesä  sª   





&


ÿÿÿ*




ÿzTypeJoinVisitor.join_tuplesc                 C  s¦   t | jtƒrI| jd u rtƒ | _| j tj | j¡tj |¡¡}t |t	ƒs&J ‚|  
| j|¡}|d ur6t||ƒS t| j|ƒr>|S t|| jƒrG| jS |S t| jtj |¡ƒS r5   )rI   r=   r   r‹   r2   rn   r   r€   rJ   r   rì   r   rP   )r7   r<   r^   rX   r8   r8   r9   Úvisit_tuple_typeO  s    
ÿ
z TypeJoinVisitor.visit_tuple_typer"   c                   s”   t ˆ jtƒr7‡ ‡fdd„ˆ j ˆ¡D ƒ}ˆ j ¡ }t| ¡ ƒ}|ˆj@ ˆ jj@ }ˆjˆjB |@ }t||||ƒS t ˆ jt	ƒrDt
ˆ jˆjƒS ˆ  ˆ j¡S )Nc                   s8   i | ]\}}}t ||ƒr|ˆjv |ˆ jjv kr||“qS r8   )r   Úrequired_keysr=   )rª   Ú	item_nameÚs_item_typeÚt_item_typer’   r8   r9   Ú
<dictcomp>q  s    üüz8TypeJoinVisitor.visit_typeddict_type.<locals>.<dictcomp>)rI   r=   r"   rM   Úcreate_anonymous_fallbackÚsetÚkeysrî   Úreadonly_keysr   rP   r^   rŸ   )r7   r<   rX   r^   Úall_keysrî   rö   r8   r’   r9   Úvisit_typeddict_typeo  s   
þ
z$TypeJoinVisitor.visit_typeddict_typer   c                 C  s`   t | jtƒr)|| jkr|S | jjjjr!|jjjr!tj | j|g¡S t	| jj|jƒS t	| j|jƒS r5   )
rI   r=   r   r^   rC   Úis_enumr   r€   r‚   rP   r’   r8   r8   r9   Úvisit_literal_type†  s   
z"TypeJoinVisitor.visit_literal_typer   c                 C  s   J dƒ‚)NFzInternal errorr8   r’   r8   r8   r9   Úvisit_partial_type  s   z"TypeJoinVisitor.visit_partial_typer$   c                 C  sT   t | jtƒrtjt|j| jjƒ|jdS t | jtƒr$| jjj	dkr$| jS |  
| j¡S )N)Úlinezbuiltins.type)rI   r=   r$   Úmake_normalizedrP   Úitemrü   r   rC   rV   rŸ   r’   r8   r8   r9   Úvisit_type_type•  s
   zTypeJoinVisitor.visit_type_typer!   c                 C  s   J d|› ƒ‚)NFz!This should be never called, got r8   r’   r8   r8   r9   Úvisit_type_alias_type  s   z%TypeJoinVisitor.visit_type_alias_typeÚtypr    c                 C  s¬   t |ƒ}t|tƒrt|ƒS t|tƒrttjƒS t|tƒr%|  	t
j |¡¡S t|tƒr0|  	|j¡S t|tƒr;|  	|j¡S t|tƒrF|  	|j¡S t|tƒrQ|  	|j¡S ttjƒS r5   )r/   rI   r   rA   r*   r   r#   r‘   r   rŸ   r   r€   rJ   r"   r^   r   r(   rT   r   )r7   r  r8   r8   r9   rŸ      s    








zTypeJoinVisitor.defaultr5   )r=   r   r‹   rŒ   r3   r4   )r<   r*   r3   r   )r<   r,   r3   r   )r<   r   r3   r   )r<   r   r3   r   )r<   r+   r3   r   )r<   r   r3   r   )r<   r   r3   r   )r<   r(   r3   r   )r<   r   r3   r   )r<   r'   r3   r   )r<   r-   r3   r-   )r<   r   r3   r   )r<   r   r3   r   )r<   r   r3   r   )r<   r   r3   r   )r=   r   r<   r   r3   rÉ   )r<   r   r3   r   )r<   r"   r3   r   )r<   r   r3   r   )r<   r   r3   r   )r<   r$   r3   r   )r<   r!   r3   r   )r  r    r3   r   )rw   rx   ry   Ú__doc__r:   r“   r”   r•   r—   rš   rœ   r   r    r£   r¥   r§   r³   r¹   rÄ   rÈ   rì   rí   rø   rú   rû   rÿ   r   rŸ   r8   r8   r8   r9   r…   %  s4    













!

5
k
 




r…   Úboolc                 C  sH   t | ƒ} t |ƒ}t| tƒr"t|tƒsdS t| jjƒt|jjƒkr"dS dS )NTF)r/   rI   r   rQ   rC   Úmro©r<   r=   r8   r8   r9   rp   ´  s   

rp   útuple[ProperType, ProperType]c                 C  s4   t | ttfƒr|  ¡ } t |ttfƒr| ¡ }| |fS r5   )rI   r   r   Úwith_unpacked_kwargsr‰   r8   r8   r9   rƒ   Ã  s
   rƒ   r   c                 C  s,   t | jƒt |jƒko| j|jko| j|jkS )zcReturn True if t and s have identical numbers of
    arguments, default arguments and varargs.
    )rQ   r®   Úmin_argsÚ
is_var_argr  r8   r8   r9   r¼   Ë  s
   
ÿ
ýr¼   ÚcÚidsúlist[TypeVarId]c                 C  sP   i }g }t | j|ƒD ]\}}|j|d}| |¡ |||j< q
t| |ƒj|dS )N)rž   )Ú	variables)rM   r  r±   rB   rž   r   )r
  r  Útv_mapÚtvsÚtvÚnew_idÚnew_tvr8   r8   r9   Úupdate_callable_idsÖ  s   
r  ú!tuple[CallableType, CallableType]c                 C  sb   t t| jƒt|jƒƒ}tt| jƒt|jƒƒ}|dkr| |fS dd„ t|ƒD ƒ}t| |ƒt||ƒfS )Nr   c                 S  s   g | ]}t jd d‘qS )r   )Ú
meta_level)r%   Únew)rª   Ú_r8   r8   r9   r­   ì  s    z+match_generic_callables.<locals>.<listcomp>)ÚmaxrQ   r  ÚminrÒ   r  )r<   r=   Úmax_lenÚmin_lenÚnew_idsr8   r8   r9   Úmatch_generic_callablesà  s   r  c                 C  ó‚   t | |ƒ\} }g }tt| jƒƒD ]}| t| j| |j| ƒ¡ q| jjjdkr,| j}n|j}| j	|t
| |ƒt| j|jƒ|d dS ©Nzbuiltins.function)r®   r¯   Úret_typer^   Úname)r  rÒ   rQ   r®   rB   Ú	safe_meetr^   rC   rV   r±   r²   rP   r   ©r<   r=   r®   rÌ   r^   r8   r8   r9   r¾   ñ  s   ûr¾   c                 C  sP   t | tƒst |tƒst| |ƒS t | tƒr"t |tƒr"tt| j|jƒƒS tt| ƒƒS r5   )rI   r-   rP   rC   rˆ   r/   r  r8   r8   r9   Ú	safe_join  s
   
r$  c                 C  sÂ   ddl m} t| tƒst|tƒs|| |ƒS t| tƒr^t|tƒr^t| jƒ}t|tƒr.|jj}nt|tƒr8|j	j}nt|t
ƒrC|jjdksEJ ‚|j}|| j|jƒ}t|tƒrZt
||gƒ}t|ƒS tƒ S )Nr   r¨   r>   )r°   r©   rI   r-   r/   rC   r'   rJ   r   Úpartial_fallbackr   rV   r+   )r<   r=   r©   rè   Úfallback_typeru   r8   r8   r9   r"    s    






r"  c                 C  r  r  )r  rÒ   rQ   r®   rB   r$  r^   rC   rV   r±   r²   rP   r   r#  r8   r8   r9   r½   &  s   ûr½   úCallableType | Parametersúlist[str | None]c                 C  sn   t | jƒ}g }t|ƒD ])}| j| }|j| }||ks)| j|  ¡ s)|j|  ¡ r/| |¡ q| d¡ q|S )aL  Produces a list of argument names compatible with both callables.

    For example, suppose 't' and 's' have the following signatures:

    - t: (a: int, b: str, X: str) -> None
    - s: (a: int, b: str, Y: str) -> None

    This function would return ["a", "b", None]. This information
    is then used above to compute the join of t and s, which results
    in a signature of (a: int, b: str, str) -> None.

    Note that the third argument's name is omitted and 't' and 's'
    are both valid subtypes of this inferred signature.

    Precondition: is_similar_types(t, s) is true.
    N)rQ   r®   rÒ   r¯   Ú	arg_kindsÚis_namedrB   )r<   r=   Únum_argsÚ	new_namesrÌ   Út_nameÚs_namer8   r8   r9   r²   <  s   


$r²   Úinstancer   c                 C  s   t | jjd g ƒ}|S )z;Construct the type 'builtins.object' from an instance type.éÿÿÿÿ)r   rC   r  )r/  ru   r8   r8   r9   rA   [  s   rA   r  c                 C  sÒ   t | tƒr	t| ƒS t | tttfƒrt| jƒS t | tƒr t| jƒS t | t	ƒr*t
| jƒS t | tƒr:t | jtƒr:t
| jƒS t | tƒrX| jD ]}t |tƒrVt
|ƒ}t |tƒrV|  S qBnt | tƒrdt
t| jƒƒ ttjƒS r5   )rI   r   rA   r   r"   r   r^   r   r%  r$   rˆ   rþ   r&   rT   r   r,   rX   r-   r/   rC   r   r#   Úimplementation_artifact)r  rþ   Ú	candidater8   r8   r9   rˆ   b  s*   










€ü

rˆ   ÚtypesúSequence[Type]c                 C  s2   | st ƒ S | d }| dd … D ]}t||ƒ}q|S )Nr   rÅ   )r+   rP   )r3  rÞ   r<   r8   r8   r9   rÔ   z  s   rÔ   úProperType | Nonec                 C  s2   | j jsJ ‚| j jdgkrttd| | ddƒS d S )NÚ__call__T)Úis_operator)rC   r´   Úprotocol_membersr/   r   )r<   r8   r8   r9   rµ   …  s   rµ   )rz   r{   r=   r    r<   r    r3   r   )r=   r    r<   r    r3   r    r5   )r=   r   r<   r   r‹   rŒ   r3   r   )r=   r    r<   r    r‹   rŒ   r3   r    )r<   r    r=   r    r3   r  )r=   r   r<   r   r3   r  )r<   r   r=   r   r3   r  )r
  r   r  r  r3   r   )r<   r   r=   r   r3   r  )r<   r   r=   r   r3   r   )r<   r    r=   r    r3   r    )r<   r'  r=   r'  r3   r(  )r/  r   r3   r   )r  r   r3   r   )r3  r4  r3   r    )r<   r   r3   r5  )Nr  Ú
__future__r   Útypingr   r   Úmypy.typeopsr   Úmypy.expandtyper   Úmypy.maptyper   Ú
mypy.nodesr   r   r	   r
   Ú
mypy.stater   Úmypy.subtypesr   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-   r.   r/   r0   r1   r2   r‡   rŠ   rP   r…   rp   rƒ   r¼   r  r  r¾   r$  r"  r½   r²   rA   rˆ   rÔ   rµ   r8   r8   r8   r9   Ú<module>   sL     ˆ$ 

1
ÿ'   














