o
    2g                     @  s  U d Z ddlm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 dd	lmZ dd
lmZ ddlmZ ddlmZ ddlmZ ddlmZmZmZmZmZmZm Z  ddl!m"Z" ddl#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z, ddl-m.Z. ddl/m0Z0 ddl1m2Z2m3Z3m4Z4m5Z5 ddl6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZF ddlGmHZH ddlImJZJ g dZKdeLd< g dZMdeLd< G dd deZNG dd deJeN ZOd2d$d%ZPd3d)d*ZQd4d-d.ZRd5d0d1ZSdS )6z?Pattern checker. This file is conceptually part of TypeChecker.    )annotations)defaultdict)Final
NamedTupleN)message_registry)analyze_member_access)expand_type_by_instance)
join_typesliteral_hash)map_instance_to_supertype)narrow_declared_type)MessageBuilder)ARG_POSContext
ExpressionNameExpr	TypeAliasTypeInfoVar)Options)		AsPatternClassPatternMappingPattern	OrPatternPatternSequencePatternSingletonPatternStarredPatternValuePattern)Plugin)
is_subtype)coerce_to_literalmake_simplified_union"try_getting_str_literals_from_typetuple_fallback)AnyTypeInstanceLiteralTypeNoneType
ProperType	TupleTypeTypeTypedDictType	TypeOfAnyTypeVarTupleTypeUninhabitedType	UnionType
UnpackTypefind_unpack_in_listget_proper_typesplit_with_prefix_and_suffix)fill_typevars)PatternVisitor)builtins.boolbuiltins.bytearraybuiltins.bytesbuiltins.dictzbuiltins.floatzbuiltins.frozensetzbuiltins.intbuiltins.listzbuiltins.setbuiltins.strbuiltins.tupler   self_match_type_names)r=   r:   r9   non_sequence_match_type_namesc                   @  s&   e Zd ZU ded< ded< ded< dS )PatternTyper,   type	rest_typedict[Expression, Type]capturesN)__name__
__module____qualname____annotations__ rJ   rJ   I/home/garg/my-data/venv/lib/python3.10/site-packages/mypy/checkpattern.pyrA   O   s   
 rA   c                   @  s,  e Zd ZU dZded< ded< ded< ded	< d
ed< ded< ded< ded< ded< dbddZdcddZddddZdedd Zdfd"d#Z	dgd%d&Z
dhd(d)Zdid.d/Zdjd5d6Zdkd:d;Zdld=d>Zdmd@dAZdndEdFZdodGdHZdpdJdKZdqdMdNZdrdPdQZdsdTdUZdtdYdZZdud]d^Zdvd_d`ZdaS )wPatternCheckerzPattern checker.

    This class checks if a pattern can match a type, what the type can be narrowed to, and what
    type capture patterns should be inferred as.
    mypy.checker.TypeCheckerchkr   msgr    pluginr   subjectr,   subject_type
list[Type]type_contextself_match_typesnon_sequence_match_typesr   optionsreturnNonec                 C  s:   || _ || _|| _g | _| t| _| t| _|| _	d S N)
rN   rO   rP   rT   generate_types_from_namesr?   rU   r@   rV   rW   )selfrN   rO   rP   rW   rJ   rJ   rK   __init__q   s   
zPatternChecker.__init__or   rA   c                 C  s$   | j | || }| j   |S rZ   )rT   appendacceptpop)r\   r^   rT   resultrJ   rJ   rK   r`      s   

zPatternChecker.acceptr   c                 C  s   | j d }|jd ur| |j|}|\}}}n	|t i }}}t|sA|jd urA| jj|t|g||d\}}t|sA|||j< t	|||S Ndefault)
rT   patternr`   r0   is_uninhabitednamerN   #conditional_types_with_intersectionget_type_rangerA   )r\   r^   current_typepattern_typetyprC   type_map_rJ   rJ   rK   visit_as_pattern   s   



zPatternChecker.visit_as_patternr   c                 C  sf  | j d }g }|jD ]}| ||}|| |j}q
g }|D ]}t|js,||j qtt}|d j	
 D ]\}}	t|}
||
 ||	f q8t|dd  D ]6\}}dd |j	
 D }| |krq| jtj|j|  |j	
 D ]\}}	t|}
||
 ||	f qvqRi }| D ]}t }	|D ]	\}}t|	|}	q|	||d d < qt|}t|||S )Nrd   r      c                 S  s   h | ]\}}t |qS rJ   )get_var).0exprrp   rJ   rJ   rK   	<setcomp>       z2PatternChecker.visit_or_pattern.<locals>.<setcomp>)rT   patternsr`   r_   rC   rh   rB   r   listrE   itemsrs   	enumeratekeysrO   failr   OR_PATTERN_ALTERNATIVE_NAMESvaluesr0   r	   r#   rA   )r\   r^   rl   pattern_typesrg   rm   typescapture_typesru   rn   nodeivarsrE   capture_listrp   other
union_typerJ   rJ   rK   visit_or_pattern   s>   



zPatternChecker.visit_or_patternr   c                 C  sx   | j d }| jj|j}t|}| jj|t|g|t|d\}}t	t|t
tfs6t|t||gi S t||i S rc   )rT   rN   expr_checkerr`   ru   r"   rj   rk   r4   
isinstancer(   r0   rA   r1   
make_union)r\   r^   rl   rn   narrowed_typerC   rJ   rJ   rK   visit_value_pattern   s   

z"PatternChecker.visit_value_patternr   c                 C  sj   | j d }|j}t|tr| jj|d}n
|d u rt }nJ | jj|t	|g||d\}}t
||i S )Nrd   r8   Fre   )rT   valuer   boolrN   r   infer_literal_expr_typer)   rj   rk   rA   )r\   r^   rl   r   rn   r   rC   rJ   rJ   rK   visit_singleton_pattern   s   


z&PatternChecker.visit_singleton_patternr   c           !      C  s  t | jd }| |s|  S dd t|jD }d }t|dkr'|d }n
t|dkr1J dt|j}|d ur>|d8 }d }t|tr|j	}t
|}|d u rkt|| }|dk r^|  S |dkrj|d u rj|  S nNg }	|D ]}
t|
trt|
jtrt|
jj}
|	|
 qo|	}|j|	d	}t|d |kr|d u r|  S n| ||}|d u r| jd
}|gt|j }g }g }i }| |||}t|j|D ]\}}| ||}|\}}}|| || | || q| ||t||d u}| ||t||d u}|}t|try|d u ryg }g }t||D ]\}}| jj|t|g||d\}}|| || qtdd |D rJt||j}nt }tdd |D r^t||j}nctdd |D dkrxtdd t||D |j}nHt|trt||j}| jj|t|g||d\}}n,t }|D ]}t||}q|  ||}t!||r| jj|t|g||d\}} n|}t"|||S )Nrd   c                 S  s   g | ]\}}t |tr|qS rJ   )r   r   )rt   r   prJ   rJ   rK   
<listcomp>   s    z9PatternChecker.visit_sequence_pattern.<locals>.<listcomp>rr   r      Fz/Parser should prevent multiple starred patterns)rz   builtins.objectre   c                 s      | ]}t | V  qd S rZ   rh   rt   rn   rJ   rJ   rK   	<genexpr>;      z8PatternChecker.visit_sequence_pattern.<locals>.<genexpr>c                 s  s    | ]}t |V  qd S rZ   r   r   rJ   rJ   rK   r   @  s    c                 s  r   rZ   r   r   rJ   rJ   rK   r   C  r   c                 S  s    g | ]\}}t |r|n|qS rJ   r   )rt   currrestrJ   rJ   rK   r   G  s    )#r4   rT   can_match_sequenceearly_non_matchr{   rx   lenr   r+   rz   r3   r2   rB   r/   upper_boundr_   copy_modifiedget_sequence_typerN   
named_typecontract_starred_pattern_typeszipr`   update_type_mapexpand_starred_pattern_typesrj   rk   allpartial_fallbackr0   sumr	   construct_sequence_childr!   rA   )!r\   r^   rl   star_positionsstar_positionrequired_patternsunpack_indexinner_types	size_diffnormalized_inner_typesit
inner_typecontracted_new_inner_typescontracted_rest_inner_typesrE   contracted_inner_typesr   trm   rn   r   ro   new_inner_typesrest_inner_typesrC   narrowed_inner_typesinner_rest_typesnew_inner_typenarrowed_inner_typeinner_rest_typenew_typenew_tuple_typerp   rJ   rJ   rK   visit_sequence_pattern   s   







z%PatternChecker.visit_sequence_patternr   contextr   Type | Nonec                   s   t |}t|trttj|S t|tr. fdd|jD }dd |D }|r,t|S d S j	|rKt|t
tfrKt|trDt|}j| S d S )Nc                   s   g | ]} | qS rJ   )r   rt   itemr   r\   rJ   rK   r   g  rw   z4PatternChecker.get_sequence_type.<locals>.<listcomp>c                 S  s   g | ]}|d ur|qS rZ   rJ   r   rJ   rJ   rK   r   h  rw   )r4   r   r&   r.   from_another_anyr1   rz   r#   rN   type_is_iterabler'   r+   r%   iterable_item_type)r\   r   r   rz   not_none_itemsrJ   r   rK   r   b  s   


z PatternChecker.get_sequence_typer   star_pos
int | Nonenum_patternsintc                   sf  t |}|dur|| }t|tsJ t|j t tr# jjdks%J |du rM|t| d }|d| }| jd g| 7 }|||d d 7 }|S t	t
 fdd|D ||| \}}	}
g }|	D ]}t|tru| jd  qe|| qet|t|g t|
 S |du r|S |d| }t|| }|t||||   |||| d 7 }|S )aj  
        Contracts a list of types in a sequence pattern depending on the position of a starred
        capture pattern.

        For example if the sequence pattern [a, *b, c] is matched against types [bool, int, str,
        bytes] the contracted types are [bool, Union[int, str], bytes].

        If star_pos in None the types are returned unchanged.
        Nr>   rr   r   c                   s"   g | ]}t |trt n|qS rJ   )r   r2   )rt   r   unpackedrJ   rK   r     s   " zAPatternChecker.contract_starred_pattern_types.<locals>.<listcomp>)r3   r   r2   r4   rB   r'   fullnamer   argsr5   tupler_   ry   r#   )r\   r   r   r   r   unpackmissing	new_typesprefixmiddlesuffix
new_middlemstar_lengthrJ   r   rK   r   u  s<   


z-PatternChecker.contract_starred_pattern_types	num_typesoriginal_unpackr   c           
      C  s   |du r|S |r,g }t |D ]\}}||kr|| q|t| jd|g q|S |d| }|t| d }	||| g|	 7 }|||d d 7 }|S )zUndoes the contraction done by contract_starred_pattern_types.

        For example if the sequence pattern is [a, *b, c] and types [bool, int, str] are extended
        to length 4 the result is [bool, int, int, str].
        Nr>   rr   )r{   r_   r2   rN   named_generic_typer   )
r\   r   r   r   r   resr   r   r   r   rJ   rJ   rK   r     s   z+PatternChecker.expand_starred_pattern_typesr   c                 C  sB   i }|j d ur| jd| jd g}|||j < t| jd t |S )Nr<   rd   )capturerN   r   rT   rA   r0   )r\   r^   rE   	list_typerJ   rJ   rK   visit_starred_pattern  s
   

z$PatternChecker.visit_starred_patternr   c                 C  s  t | jd }d}i }t|j|jD ],\}}| |||}|d u r)d}| jd}| ||}t	|j
r7d}q| ||j q|jd ur{| jd}	t||	rgt|trgt||	j
}
| jd}t||
j}n| jd}| jd||g}|||j< |r| jd }nt }t|||S )Nrd   TFr   ztyping.Mappingr;   )r4   rT   r   r|   r   get_mapping_item_typerN   r   r`   rh   rB   r   rE   r   r!   r   r'   r   lookup_typeinfor   r   r0   rA   )r\   r^   rl   	can_matchrE   keyr   r   rm   mappingmapping_instdict_typeinforC   object_typer   rJ   rJ   rK   visit_mapping_pattern  s6   


z$PatternChecker.visit_mapping_patternrg   mapping_typer   c                 C  s   t |}t|tr[| j }| jj||d }| }W d    n1 s'w   Y  |rY| j }| 	|||}| rId }W d    |S W d    |S 1 sTw   Y  |S | j  | 	|||}W d    |S 1 ssw   Y  |S )Nr   )
r4   r   r-   rO   filter_errorsrN   r   visit_typeddict_index_exprhas_new_errorsget_simple_mapping_item_type)r\   rg   r   r   local_errorsrb   has_local_errorsrJ   rJ   rK   r     s8   




z$PatternChecker.get_mapping_item_typec                 C  s"   | j jd||gtg|\}}|S )N__getitem__)rN   r   check_method_call_by_namer   )r\   rg   r   r   rb   rp   rJ   rJ   rK   r     s   z+PatternChecker.get_simple_mapping_item_typer   c           "      C  s  t | jd }|jj}|d u rtttjttji S t|t	r/|j
s/| jtj| |  S t|tr`ttj}g }|jjD ]}t|trT|t| jd|g q?|| q?t||}nCt|t	ri|j}n:t|tr|jd urtt |jtr|j}n$t|tr|jd ur|j| j}n|j}| jtj !|| |  S | jj"|t#|g||d\}	}
t$|	r|  S t%||	}g }t& }i }t'|j(dkr| )|rt'|j(dkr| jtj*| | +|j(d |}t$|jst|jt,|
|j-|j.S |j.}n| j/ }t0d||ddd| j|| jd	}|1 }W d    n	1 s%w   Y  |r@| jtj2!|| j| |  S t |}t|t3ret4|}t'|j(t'|krd| jtj*| |  S nd gt'|j( }t5||j(D ]\}}|||f |d ur|6| qst& }d}t5|j7|j8D ]6\}}|||f ||v r| jtj9!|| d	}n||v r| jtj:!|| d	}|6| q|r|  S d	}|D ]w\}}d }| j/ &}|d urt0|||ddd| j|	| jd	}nttj}|1 }W d    n	1 sw   Y  |s|d u r/ttj}| jtj;!|| j|| | +||\}} }!t$|rAd}q| <||! t$| sN|}
q|sVt= }	t|	|
|S )
Nrd   r>   re   r   rr   __match_args__F)	is_lvalueis_superis_operatorrO   original_typerN   T)>r4   rT   	class_refr   rA   r&   r.   
from_errorr   r   no_argsrO   r}   r    CLASS_PATTERN_GENERIC_TYPE_ALIASr   r   implementation_artifactdefn	type_varsr/   r_   r2   rN   r   r'   targetr   rB   str_with_optionsrW   ri   CLASS_PATTERN_TYPE_REQUIREDformatrj   rk   rh   r   setr   positionalsshould_self_match&CLASS_PATTERN_TOO_MANY_POSITIONAL_ARGSr`   r	   rC   rE   r   r   r   MISSING_MATCH_ARGSr+   get_match_arg_namesr   addkeyword_keyskeyword_values(CLASS_PATTERN_KEYWORD_MATCHES_POSITIONAL'CLASS_PATTERN_DUPLICATE_KEYWORD_PATTERNCLASS_PATTERN_UNKNOWN_KEYWORDr   r0   )"r\   r^   rl   	type_infoany_typer   tvrn   ri   r   rC   r   keyword_pairsmatch_arg_setrE   rm   r   match_args_typer   proper_match_args_typematch_arg_namesarg_nameposkeyword_arg_sethas_duplicatesr   r   r   keywordrg   key_typer   r   inner_capturesrJ   rJ   rK   visit_class_pattern  s  




















z"PatternChecker.visit_class_patternrn   c                 C  s>   t |}t|tr|jjrdS | jD ]
}t||r dS qdS )NFT)r4   r   r'   rB   is_named_tuplerU   r!   )r\   rn   r   rJ   rJ   rK   r
    s   

z PatternChecker.should_self_matchr*   c                   sb   t |trt fdd|jD S  jD ]}t||ddr  dS q jd}t||p0t||S )Nc                 3  s    | ]
}  t|V  qd S rZ   )r   r4   r   r\   rJ   rK   r     s    z4PatternChecker.can_match_sequence.<locals>.<genexpr>T)ignore_promotionsFtyping.Sequence)r   r1   anyrz   rV   r!   rN   r   )r\   rn   r   sequencerJ   r%  rK   r     s   

z!PatternChecker.can_match_sequence
type_names	list[str]c                 C  sZ   g }|D ]&}z| | j| W q ty* } z|ds |W Y d }~qd }~ww |S )Nz	builtins.)r_   rN   r   KeyError
startswith)r\   r*  r   ri   erJ   rJ   rK   r[     s   
z(PatternChecker.generate_types_from_namesoriginal_type_maprD   extra_type_mapc                 C  sZ   dd |D }|  D ]\}}t||v r&t|}| jtj|j| q|||< qd S )Nc                 S  s   h | ]}t |qS rJ   r
   )rt   ru   rJ   rJ   rK   rv     s    z1PatternChecker.update_type_map.<locals>.<setcomp>)	rz   r   rs   rO   r}   r   MULTIPLE_ASSIGNMENTS_IN_PATTERNr  ri   )r\   r/  r0  already_capturedru   rn   r   rJ   rJ   rK   r     s   
zPatternChecker.update_type_map
outer_typer   c                   s   t |}t|tr fdd|jD }t|S jd g}t|jdrLt |}t|t	r6t
|}t|ts=J t|j}t||}t||S |S )a  
        If outer_type is a child class of typing.Sequence returns a new instance of
        outer_type, that is a Sequence of inner_type. If outer_type is not a child class of
        typing.Sequence just returns a Sequence of inner_type

        For example:
        construct_sequence_child(List[int], str) = List[str]

        TODO: this doesn't make sense. For example if one has class S(Sequence[int], Generic[T])
        or class T(Sequence[Tuple[T, T]]), there is no way any of those can map to Sequence[str].
        c                   s&   g | ]} t|r| qS rJ   )r   r4   r   r   r   r\   rJ   rK   r     s    
z;PatternChecker.construct_sequence_child.<locals>.<listcomp>r'  )r4   r   r1   rz   r#   rN   r   r!   r   r+   r%   r'   r6   rB   r   )r\   r3  r   proper_typer   r)  
empty_typepartial_typerJ   r4  rK   r     s    




z'PatternChecker.construct_sequence_childc                 C  s   t t | jd i S )Nrd   )rA   r0   rT   r%  rJ   rJ   rK   r     s   zPatternChecker.early_non_matchN)
rN   rM   rO   r   rP   r    rW   r   rX   rY   )r^   r   rT   r,   rX   rA   )r^   r   rX   rA   )r^   r   rX   rA   )r^   r   rX   rA   )r^   r   rX   rA   )r^   r   rX   rA   )r   r,   r   r   rX   r   )r   rS   r   r   r   r   rX   rS   )
r   rS   r   r   r   r   r   r   rX   rS   )r^   r   rX   rA   )r^   r   rX   rA   )rg   r   r   r,   r   r   rX   r   )rg   r   r   r,   r   r   rX   r,   )r^   r   rX   rA   rn   r,   rX   r   )rn   r*   rX   r   )r*  r+  rX   rS   )r/  rD   r0  rD   rX   rY   )r3  r,   r   r,   rX   r,   )rX   rA   )rF   rG   rH   __doc__rI   r]   r`   rq   r   r   r   r   r   r   r   r   r   r   r   r#  r
  r   r[   r   r   r   rJ   rJ   rJ   rK   rL   U   sD   
 




1

 


1


$

 
+
	


 rL   rn   r+   rX   list[str | None]c                 C  sJ   g }| j D ]}t|}|d u st|dkr|d  q||d  q|S )Nrr   r   )rz   r$   r   r_   )rn   r   r   r   rJ   rJ   rK   r  	  s   
r  ru   r   r   c                 C  s&   t | tsJ | j}t |tsJ |S )zx
    Warning: this in only true for expressions captured by a match statement.
    Don't call it from anywhere else
    )r   r   r   r   )ru   r   rJ   rJ   rK   rs     s   rs   r,   mypy.checker.TypeRangec                 C  s<   t | } t| tr| jrt| jjtr| j} tjj| ddS )NF)is_upper_bound)	r4   r   r'   last_known_valuer   r   mypychecker	TypeRangern   rJ   rJ   rK   rk     s   rk   r   c                 C  s   t t| tS rZ   )r   r4   r0   rA  rJ   rJ   rK   rh   *  s   rh   )rn   r+   rX   r:  )ru   r   rX   r   )rn   r,   rX   r;  r8  )Tr9  
__future__r   collectionsr   typingr   r   mypy.checkerr>  r   mypy.checkmemberr   mypy.expandtyper   	mypy.joinr	   mypy.literalsr   mypy.maptyper   	mypy.meetr   mypy.messagesr   
mypy.nodesr   r   r   r   r   r   r   mypy.optionsr   mypy.patternsr   r   r   r   r   r   r   r   r   mypy.pluginr    mypy.subtypesr!   mypy.typeopsr"   r#   r$   r%   
mypy.typesr&   r'   r(   r)   r*   r+   r,   r-   r.   r/   r0   r1   r2   r3   r4   r5   mypy.typevarsr6   mypy.visitorr7   r?   rI   r@   rA   rL   r  rs   rk   rh   rJ   rJ   rJ   rK   <module>   sF    $,H     
9

