
    %^gg                        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@mAZAmBZBmCZCmDZDmEZEmFZFmGZG ddlHmIZI ddlJmKZK g dZLdeMd<   g dZNdeMd<    G d de      ZO G d deKeO         ZPd$d ZQd%d!ZRd&d"ZSd'd#ZTy)(z?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TypeVarType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;   r:   non_sequence_match_type_namesc                  ,    e Zd ZU ded<   ded<   ded<   y)PatternTyper,   type	rest_typedict[Expression, Type]capturesN)__name__
__module____qualname____annotations__     1lib/python3.12/site-packages/mypy/checkpattern.pyrC   rC   P   s    
JO$$rM   rC   c                     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<   	 	 	 	 	 	 	 	 	 	 d)dZd*dZd+dZd,dZd-dZ	d.dZ
d/dZd0dZ	 	 	 	 	 	 	 	 d1dZ	 	 	 	 	 	 	 	 	 	 d2dZd3dZd4dZd5dZ	 	 	 	 	 	 	 	 d6dZ	 	 	 	 	 	 	 	 d7d Zd8d!Zd9d"Zd:d#Zd;d$Z	 	 	 	 	 	 d<d%Zd=d&Zd>d'Zy()?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   optionsc                    || _         || _        || _        g | _        | j	                  t
              | _        | j	                  t              | _        || _	        y N)
rR   rS   rT   rX   generate_types_from_namesr@   rY   rA   rZ   r[   )selfrR   rS   rT   r[   s        rN   __init__zPatternChecker.__init__r   sT      $ > >?T U(,(F(F))
% rM   c                    | j                   j                  |       |j                  |       }| j                   j                          |S r]   )rX   appendacceptpop)r_   orX   results       rN   rc   zPatternChecker.accept   s:      .$rM   c                n   | j                   d   }|j                  #| j                  |j                  |      }|\  }}}n|t               i }}}t	        |      sR|j
                  F| j                  j                  |t        |      g||      \  }}t	        |      s|||j
                  <   t        |||      S Ndefault)
rX   patternrc   r1   is_uninhabitednamerR   #conditional_types_with_intersectionget_type_rangerC   )r_   re   current_typepattern_typetyprE   type_map_s           rN   visit_as_patternzPatternChecker.visit_as_pattern   s    ((,99 ;;qyy,?L'3$CH'3_5FHCc"qvv'9XXAA~c23Q B FC "#&#& 3	844rM   c                ^   | j                   d   }g }|j                  D ]G  }| j                  ||      }|j                  |       t	        |j
                        r<|j                  }I g }|D ]3  }t	        |j
                        r|j                  |j
                         5 t        t              }|d   j                  j                         D ]&  \  }}	t        |      }
||
   j                  ||	f       ( t        |dd        D ]  \  }}|j                  j                         D ch c]  \  }}t        |       }}}|j                         |k7  r7| j                  j                  t         j"                  |j                  |          |j                  j                         D ]&  \  }}	t        |      }
||
   j                  ||	f       (  i }|j%                         D ]-  }t'               }	|D ]  \  }}t)        |	|      }	 |	||d   d   <   / t+        |      }t-        |||      S c c}}w )Nri   r      )rX   patternsrc   rb   rm   rD   rE   r   listrG   itemsget_var	enumeratekeysrS   failr   OR_PATTERN_ALTERNATIVE_NAMESvaluesr1   r
   r#   rC   )r_   re   rq   pattern_typesrl   rr   typescapture_typesexprrs   nodeiru   varsrG   capture_listother
union_types                     rN   visit_or_patternzPatternChecker.visit_or_pattern   s
   ((,
 zzG;;w=L  .!,"3"34+55	 " )L!,"3"34\../ * CNdBS&q)2288:ID#4=D$&&c{3 ;
  )qr):;OA|1=1F1F1L1L1NO1NgdAGDM1NDO!!#t+.KKQZZXY][)2288:	ct}d#**D#;7 ;	  < ,.)002L!#C(5 e, ) ,/H\!_Q'( 3 +51
:|X>>! Ps   (H)c                   | j                   d   }| j                  j                  j                  |j                        }t        |      }| j                  j                  |t        |      g|t        |            \  }}t        t        |      t        t        f      s"t        |t        j                  ||g      i       S t        ||i       S rh   )rX   rR   expr_checkerrc   r   r"   ro   rp   r5   
isinstancer(   r1   rC   r2   
make_union)r_   re   rq   rs   narrowed_typerE   s         rN   visit_value_patternz"PatternChecker.visit_value_pattern   s    ((,hh##**1662$#'88#O#O>#./OC<P $P $
 y /-8;:XY}i.B.BMS\C].^`bcc=)R88rM   c                6   | j                   d   }|j                  }t        |t              r'| j                  j
                  j                  |d      }n|t               }nJ | j                  j                  |t        |      g||      \  }}t        ||i       S )Nri   r9   rj   )rX   valuer   boolrR   r   infer_literal_expr_typer)   ro   rp   rC   )r_   re   rq   r   rs   r   rE   s          rN   visit_singleton_patternz&PatternChecker.visit_singleton_pattern   s    ((,WWeT"((''??WC]*C5#'88#O#O>#./L $P $
 y =)R88rM   c           	     	   t        | j                  d         }| j                  |      s| j                         S t	        |j
                        D cg c]  \  }}t        |t              s| }}}d }t        |      dk(  r|d   }nt        |      dk\  rJ d       t        |j
                        }||dz  }d }t        |t              r|j                  }	t        |	      }|:t        |	      |z
  }
|
dk  r| j                         S |
dkD  r|| j                         S g }|	D ]\  }t        |t              r9t        |j                  t              rt        |j                  j                        }|j!                  |       ^ |}	|j#                  |      }t        |	      dz
  |kD  rZ|X| j                         S | j%                  ||      }|| j&                  j)                  d      }|gt        |j
                        z  }	g }g }i }| j+                  |	||      }t-        |j
                  |      D ]Q  \  }}| j/                  ||      }|\  }}}|j!                  |       |j!                  |       | j1                  ||       S | j3                  ||t        |	      |d u      }| j3                  ||t        |	      |d u      }|}t        |t              r|g }g }t-        |	|      D ]S  \  }}| j&                  j5                  |t7        |      g||      \  }}|j!                  |       |j!                  |       U t9        d	 |D              rt        ||j:                        }n
t=               }t9        d
 |D              rt        ||j:                        }nt?        d |D              dk(  rt        t-        |	|      D  cg c]  \  } }tA        |      r| n| c}} |j:                        }nt        |t              rCt        ||j:                        }!| j&                  j5                  |!t7        |      g||!      \  }}npt=               }|D ]  }tC        ||      } t        |tD              r0| jG                  |j                  ||      }"|j#                  |"      }n| jG                  |||      }tI        |||      S c c}}w c c}} w )Nri   rx   r      z/Parser should prevent multiple starred patterns)r{   builtins.objectrj   c              3  4   K   | ]  }t        |         y wr]   rm   .0rs   s     rN   	<genexpr>z8PatternChecker.visit_sequence_pattern.<locals>.<genexpr>=  s     K6Js~c**6J   c              3  2   K   | ]  }t        |        y wr]   r   r   s     rN   r   z8PatternChecker.visit_sequence_pattern.<locals>.<genexpr>B  s     C2B3>#&2Bs   c              3  4   K   | ]  }t        |         y wr]   r   r   s     rN   r   z8PatternChecker.visit_sequence_pattern.<locals>.<genexpr>E  s     I8H,,8Hr   )upper_bound)%r5   rX   can_match_sequenceearly_non_matchr}   ry   r   r   lenr+   r{   r4   r3   rD   r/   r   rb   copy_modifiedget_sequence_typerR   
named_typecontract_starred_pattern_typesziprc   update_type_mapexpand_starred_pattern_typesro   rp   allpartial_fallbackr1   sumrm   r
   r0   narrow_sequence_childrC   )#r_   re   rq   r   p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_typesrG   contracted_inner_typestrr   rs   restrt   new_inner_typesrest_inner_typesrE   narrowed_inner_typesinner_rest_typesnew_inner_typenarrowed_inner_typeinner_rest_typenew_typecurrnew_tuple_type	new_bounds#                                      rN   visit_sequence_patternz%PatternChecker.visit_sequence_pattern   s    't'8'8'<=&&|4''))(1!**(=_(=1A~A^!(=_$(~!#*1-M A%KKK5

O$"
 lI.&,,K.{;L#,/@@	q=//11]}'<//11)+&%B ""j1jJZ6['(;(;<*11"5 & 5+99@V9W{#a'*;;@U//11//a@J!!XX001BC
%,QZZ8K
 24"24#+-!%!D!D(9"
 

$:;DAq;;q!,L".Cx&--c2'..t4  84 < ;;&s;7G]aIa
  <<'K8H,^bJb
 '	lI.<3G#% !.1+.O*
NHH@@"^N%C$DaQ[ A  7$o
 %++,?@ ''8 /P K6JKK$%9<;X;XY*,C2BCC%&68U8UV	I8HIIQN & +.k;K*L*LJD$ !/t 4$>*L !11	 i0 '8U8UVN"&(("N"N!= >> #O #Hi -.N&!+NC!@ ',4 66|7O7OQ_abc	'55)5L55lNTUV8Y99k `|s   S+SS
c                   t        |      }t        |t              rt        t        j                  |      S t        |t
              rI|j                  D cg c]  }| j                  ||       }}|D cg c]  }||	 }}|rt        |      S y | j                  j                  |      rMt        |t        t        f      r7t        |t              rt        |      }| j                  j                  ||      S y c c}w c c}w r]   )r5   r   r&   r.   from_another_anyr2   r{   r   r#   rR   type_is_iterabler'   r+   r%   iterable_item_type)r_   r   contextitemr{   not_none_itemss         rN   r   z PatternChecker.get_sequence_typeb  s    Aa!955q99a#GHwwOwtT++D':wEO/4Iut8HduNI,^<<88$$Q'Jq8Y:O,P!Y'"1%88..q':: PIs   C83C=;C=c                :   t        |      }|E||   }t        |t              sJ t        |j                        }t        |t
              r|j                  j                  dk(  sJ |9|t        |      z
  dz   }|d| }||j                  d   g|z  z  }|||dz   d z  }|S t        t        |D 	cg c]  }	t        |	t              rt        |      n|	! c}	      |||z
        \  }
}}g }|D ]B  }t        |t              r|j                  |j                  d          2|j                  |       D t        |
      t        |      gz   t        |      z   S ||S |d| }t        |      |z
  }|j                  t        ||||z                 ||||z   d z  }|S c c}	w )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?   rx   r   )r4   r   r3   r5   rD   r'   fullnamer   argsr6   tuplerb   rz   r#   )r_   r   star_posnum_patternsr   unpackunpackedmissing	new_typesr   prefixmiddlesuffix
new_middlemstar_lengths                   rN   r   z-PatternChecker.contract_starred_pattern_typesu  s    +51#<(Ffj111&v{{3Hh1hmm6L6LP`6```&U3a7!-<0	hmmA./'99	U<!#3#566	  %AY^_Y^TUz!Z/Hz(+aOY^_`x'&"FFF
 J a,%%hmmA&67%%a(  <#8#D"EEVTTix(Ie*|3K25H{DZ3[\]x+5788I) `s   /$Fc           	     2   ||S |rcg }t        |      D ]Q  \  }}||k7  r|j                  |       |j                  t        | j                  j	                  d|g                   S |S |d| }|t        |      z
  dz   }	|||   g|	z  z  }|||dz   d z  }|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?   rx   )r}   rb   r3   rR   named_generic_typer   )
r_   r   r   	num_typesoriginal_unpackresr   r   r   r   s
             rN   r   z+PatternChecker.expand_starred_pattern_types  s     L C!%(1=JJqMJJz$((*E*EFVYZX[*\]^	 )
 J)8$	#e*,q0eHo&44	U8a<>**	rM   c                    | j                  ||      }t        ||      r.| j                  j                  |t	        |      g||      \  }}|S |}|S )Nrj   )construct_sequence_childr!   rR   ro   rp   )r_   
outer_typer   ctxr   ru   s         rN   r   z$PatternChecker.narrow_sequence_child  s`    00ZHh
+((FF^H56Z G KHa
  "HrM   c                    i }|j                   9| j                  j                  d| j                  d   g      }|||j                   <   t	        | j                  d   t               |      S )Nr=   ri   )capturerR   r   rX   rC   r1   )r_   re   rG   	list_types       rN   visit_starred_patternz$PatternChecker.visit_starred_pattern  sa    +-99 33OdFWFWXZF[E\]I"+HQYY4,,R0/2CXNNrM   c                r   t        | j                  d         }d}i }t        |j                  |j                        D ]}  \  }}| j                  |||      }|d}| j                  j                  d      }| j                  ||      }t        |j                        rd}b| j                  ||j                          |j                  | j                  j                  d      }	t        ||	      rXt        |t               rHt#        ||	j                        }
| j                  j%                  d      }t!        ||
j&                        }n9| j                  j                  d      }| j                  j)                  d||g      }|||j                  <   |r| j                  d   }n
t+               }t-        |||      S )Nri   TFr   ztyping.Mappingr<   )r5   rX   r   r~   r   get_mapping_item_typerR   r   rc   rm   rD   r   rG   r   r!   r   r'   r   lookup_typeinfor   r   r1   rC   )r_   re   rq   	can_matchrG   keyr   r   rr   mappingmapping_instdict_typeinforE   object_typer   s                  rN   visit_mapping_patternz$PatternChecker.visit_mapping_pattern  s   &t'8'8'<=	+-affahh/JC33A|SIJ!!	!XX001BC
;;uj9Ll//0!	$$X|/D/DE 0 66hh))*:;G,0Zh5W8w||T $ 8 8 I$]L4E4EF	"hh112CD HH77#k;%?	  )HQVV((,H&(H8\8<<rM   c                H   t        |      }t        |t              r| j                  j	                         5 }| j
                  j                  j                  ||      d   }|j                         }d d d        rJ| j                  j	                         5 }| j                  |||      }|j                         rd }d d d        |S S | j                  j	                         5  | j                  |||      }d d d        |S # 1 sw Y   xY w# 1 sw Y   S xY w# 1 sw Y   S xY w)Nr   )
r5   r   r-   rS   filter_errorsrR   r   visit_typeddict_index_exprhas_new_errorsget_simple_mapping_item_type)r_   rl   mapping_typer   local_errorsrf   has_local_errorss          rN   r   z$PatternChecker.get_mapping_item_type  s    '|4lM2'')\&*hh&;&;&V&V #'' $0#>#>#@ 	 *  XX++-!>>wVYZF#224!%	 . v '')::7LRUV *! *) .  *s#   :C>&D
 D>D
DD!c                j    | j                   j                  j                  d||gt        g|      \  }}|S )N__getitem__)rR   r   check_method_call_by_namer   )r_   rl   r   r   rf   ru   s         rN   r   z+PatternChecker.get_simple_mapping_item_type  s8     HH))CC<#	7
	 rM   c                N   t        | j                  d         }|j                  j                  }|;t	        t        t        j                        t        t        j                        i       S t        |t              rF|j                  s:| j                  j                  t        j                  |       | j                         S t        |t               rt        t        j"                        }g }|j$                  j&                  D ]Y  }t        |t(              r6|j+                  t-        | j.                  j1                  d|g                   I|j+                  |       [ t3        ||      }n t        |t              r|j4                  }nt        |t6              r<|j8                  0t        t        |j8                        t
              r|j8                  }nt        |t6              r2|j8                  &|j8                  j;                  | j<                        }n|j>                  }| j                  j                  t        j@                  jC                  |      |       | j                         S | j.                  jE                  |tG        |      g||      \  }	}
tI        |	      r| j                         S tK        ||	      }g }tM               }i }tO        |jP                        dk7  rh| jS                  |      rtO        |jP                        dkD  r*| j                  j                  t        jT                  |       | jW                  |jP                  d   |      }tI        |j8                        s5t	        |j8                  tY        |
|jZ                        |j\                        S |j\                  }n| j                  j_                         5 }ta        d||ddd| j                  || j.                  	      }|jc                         }d d d        rb| j                  j                  t        jd                  jC                  |j;                  | j<                              |       | j                         S t              }t        |tf              rfti        |      }tO        |jP                        tO        |      kD  rS| j                  j                  t        jT                  |       | j                         S d gtO        |jP                        z  }tk        ||jP                        D ],  \  }}|j+                  ||f       ||jm                  |       . tM               }d}tk        |jn                  |jp                        D ]  \  }}|j+                  ||f       ||v r<| j                  j                  t        jr                  jC                  |      |       d	}n?||v r;| j                  j                  t        jt                  jC                  |      |       d	}|jm                  |        |r| j                         S d	}|D ]5  \  }}d }| j                  j_                         5 }|)ta        |||ddd| j                  |	| j.                  	      }nt        t        j                        }|jc                         }d d d        s|lt        t        j                        }| j                  j                  t        jv                  jC                  |j;                  | j<                        |      |       | jW                  ||      \  }} }!tI        |      rd}| jy                  ||!       tI        |       r4|}
8 |s
t{               }	t	        |	|
|      S # 1 sw Y   xY w# 1 sw Y   xY w)
Nri   r?   rj   r   rx   __match_args__F)	is_lvalueis_superis_operatorrS   original_typerR   T)>r5   rX   	class_refr   rC   r&   r.   
from_errorr   r   no_argsrS   r   r    CLASS_PATTERN_GENERIC_TYPE_ALIASr   r   implementation_artifactdefn	type_varsr/   rb   r3   rR   r   r'   targetr   rD   str_with_optionsr[   rn   CLASS_PATTERN_TYPE_REQUIREDformatro   rp   rm   r   setr   positionalsshould_self_match&CLASS_PATTERN_TOO_MANY_POSITIONAL_ARGSrc   r
   rE   rG   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   r1   )"r_   re   rq   	type_infoany_typer   tvrs   rn   r   rE   r   keyword_pairsmatch_arg_setrG   rr   r  match_args_typer  proper_match_args_typematch_arg_namesarg_nameposkeyword_arg_sethas_duplicatesr   r   r   keywordrl   key_typer   r   inner_capturess"                                     rN   visit_class_patternz"PatternChecker.visit_class_pattern  sQ   &t'8'8'<=
 KK$$	wy';';<giFZFZ>[]_``i+I4E4EHHMM*KKQO''))i*y@@AH!Dnn..b"23KK"488#>#>?ORZQ[#\] KK) / !D1C	9-""Cy#&*?9>>:GD..C)S)inn.H ~~66t||D ~~HHMM*FFMMdSUVW''))"hhJJ>#./L K 
) (#'')),\8D
 ;="%%+-q}}"%%c*q}}%)HHMM"2"Y"Y[\]#{{1==+;]K%l&7&78&$))"9l.D.DE$-- 
 (00XX++-&;("'!&$) HH&) HH
'O (4'B'B'D$ . $HHMM(;;BB00> 	  //11)8)I&4i@&9:P&QO1==)C,@@&6&]&]_`a#3355'+fs1==/A&AO%(!--%HMHc!(((C9+%))(3 &I %anna.>.>?JC  #u.m#$MMTTUXY[` "&'$LLSSTWXZ_ "&$ @ ''))
 	 -GW$(H'')\&4%"'!&$) HH&. HH
 H  'y';';<H#/#>#>#@  *   8#3"9#7#78$BBII,,T\\:G 	 ;?++gx:X7Jj)!	$$X~>%o6 ,IC !.F &(H8Y99I .-B *)s   9^A^^^$	c                    t        |      }t        |t              r|j                  j	                  d      y| j
                  D ]  }t        ||      s y y)Nr  FT)r5   r   r'   rD   getrY   r!   )r_   rs   r   s      rN   r  z PatternChecker.should_self_match  sP    c"c8$6F)G)S **E#u% + rM   c                    t        |t              rt         fd|j                  D              S  j                  D ]  }t        ||d      s y  j                  j                  d      }t        ||      xs t        ||      S )Nc              3  R   K   | ]  }j                  t        |               y wr]   )r   r5   )r   r   r_   s     rN   r   z4PatternChecker.can_match_sequence.<locals>.<genexpr>  s$     \R[$t..t/DER[s   $'T)ignore_promotionsFtyping.Sequence)r   r2   anyr{   rZ   r!   rR   r   )r_   rs   r   sequences   `   rN   r   z!PatternChecker.can_match_sequence  sv    c9%\RUR[R[\\\22E #u=	 3
 88&&'89#x(EJx,EErM   c                    g }|D ]-  }	 |j                  | j                  j                  |             / |S # t        $ r}|j	                  d      s|Y d }~Sd }~ww xY w)Nz	builtins.)rb   rR   r   KeyError
startswith)r_   
type_namesr   rn   es        rN   r^   z(PatternChecker.generate_types_from_names  s`    DTXX0067  	  {3G 4s   *7	A AAc                0   |D ch c]  }t        |       }}|j                         D ]f  \  }}t        |      |v rOt        |      }| j                  j	                  t
        j                  j                  |j                        |       b|||<   h y c c}w r]   )	r   r{   r|   rS   r   r   MULTIPLE_ASSIGNMENTS_IN_PATTERNr  rn   )r_   original_type_mapextra_type_mapr   already_capturedrs   r   s          rN   r   zPatternChecker.update_type_map  s    
 <MM;L4L.;LM'--/ID#D!%55t}$DDKKDIIVX\ +.!$' 0 Ns   Bc                0   t        |      }t        |t              rN|j                  D cg c].  }| j	                  t        |            r| j                  ||      0 }}t        |      S | j                  j                  d|g      }t        || j                  j                  d            ret        |      }t        |t              rt        |      }t        |t              sJ t        |j                        }t!        ||      }t!        ||      S |S c c}w )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].
        r8  )r5   r   r2   r{   r   r   r#   rR   r   r!   r   r+   r%   r'   r7   rD   r	   )	r_   r   r   proper_typer   r   r:  
empty_typepartial_types	            rN   r   z'PatternChecker.construct_sequence_child  s    &j1k9- (---D**?4+@A --dJ?-  
 )//88../@:,Oj$(("5"56G"HI)*5K+y1,[9k8444&{'7'78J2:xHL*<EEO!s   3Dc                F    t        t               | j                  d   i       S )Nri   )rC   r1   rX   )r_   s    rN   r   zPatternChecker.early_non_match  s    ?,d.?.?.CRHHrM   N)
rR   rQ   rS   r   rT   r    r[   r   returnNone)re   r   rX   r,   rJ  rC   )re   r   rJ  rC   )re   r   rJ  rC   )re   r   rJ  rC   )re   r   rJ  rC   )re   r   rJ  rC   )r   r,   r   r   rJ  Type | None)r   rW   r   
int | Noner   intrJ  rW   )
r   rW   r   rM  r   rN  r   r   rJ  rW   )r   r,   r   r,   r   r   rJ  r,   )re   r   rJ  rC   )re   r   rJ  rC   )rl   r   r   r,   r   r   rJ  rL  )rl   r   r   r,   r   r   rJ  r,   )re   r   rJ  rC   rs   r,   rJ  r   )rs   r*   rJ  r   )r>  z	list[str]rJ  rW   )rB  rF   rC  rF   rJ  rK  )r   r,   r   r,   rJ  r,   )rJ  rC   )rH   rI   rJ   __doc__rK   r`   rc   rv   r   r   r   r   r   r   r   r   r   r   r   r   r2  r  r   r^   r   r   r   rL   rM   rN   rP   rP   V   s    
"!	N !  )(+2@JP[b	5"0?d	99|:|&//+5/EH/	/b+5BEX\	8O"=H%59@J	.%59@J	h:T	
F	.!7.I_.	.@IrM   rP   c                    g }| j                   D ]C  }t        |      }|t        |      dk7  r|j                  d        0|j                  |d          E |S )Nrx   r   )r{   r$   r   rb   )rs   r   r   r   s       rN   r  r    sR    D		3D9>S[A-KKKKq	"  KrM   c                f    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   )r   r   s     rN   r|   r|      s2    
 dH%%%99DdC   KrM   c                    t        |       } t        | t              r<| j                  r0t        | j                  j                  t
              r| j                  } t        j                  j                  | d      S )NF)is_upper_bound)	r5   r   r'   last_known_valuer   r   mypychecker	TypeRangers   s    rN   rp   rp   +  sZ    
#
C3!  s++1148""<<!!#e!<<rM   c                4    t        t        |       t              S r]   )r   r5   r1   rY  s    rN   rm   rm   6  s    oc*O<<rM   )rs   r+   rJ  zlist[str | None])r   r   rJ  r   )rs   r,   rJ  zmypy.checker.TypeRangerO  )UrP  
__future__r   collectionsr   typingr   r   mypy.checkerrV  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   r6   mypy.typevarsr7   mypy.visitorr8   r@   rK   rA   rC   rP   r  r|   rp   rm   rL   rM   rN   <module>ro     s    E " # $  ! 2 3   & 2 * ( W W W  
 
 
  $     & ( '  u  (` u _%* %|
I^K0 |
I~==rM   