B
    7Ør\„f  ã               @   sÜ  d Z ddlZddlmZ ddlmZ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 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 ddlmZ ddlmZ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„ Z*dd„ Z+ej,e*dd„ ƒƒZ-dd„ Z.dd„ Z/e*d>d d!„ƒZ0ej,d?d"d#„ƒZ1d$d%„ Z2ed&d'„ ƒZ3d(d)„ Z4d*d+„ Z5d,d-„ Z6d.d/„ Z7d0d1„ Z8d2d3„ Z9d4d5„ Z:d6d7„ Z;d8d9„ Z<d:d;„ Z=d<d=„ Z>dS )@z'
Functions evaluating the syntax tree.
é    N)Útree)Úforce_unicodeÚunicode)Údebug)Úparser_utils)Ú
ContextSetÚNO_CONTEXTSÚContextualizedNodeÚContextualizedNameÚiterator_to_context_setÚiterate_contexts)Úcompiled)Úpep0484)Ú	recursion)Úhelpers)Úanalysis)Úimports)Ú	arguments)Ú_evaluate_for_annotation)ÚClassContextÚFunctionContext)Úiterable)ÚTreeInstanceÚCompiledInstance)Ú
NameFinder)Ú	is_stringÚ
is_literalÚ	is_numberÚis_compiled)ÚCOMPARISON_OPERATORSc                s   ‡ fdd„}|S )a{  
    This is for now the way how we limit type inference going wild. There are
    other ways to ensure recursion limits as well. This is mostly necessary
    because of instance (self) access that can be quite tricky to limit.

    I'm still not sure this is the way to go, but it looks okay for now and we
    can still go anther way in the future. Tests are there. ~ dave
    c                sp   | j }| j}y4|j|  d7  < |j| dkr>t d|¡ tS W n tk
r^   d|j|< Y nX ˆ | f|ž|ŽS )Né   i,  z-In context %s there were too many inferences.)Ú	tree_nodeÚ	evaluatorZinferred_element_countsr   Úwarningr   ÚKeyError)ÚcontextÚargsÚkwargsÚnr"   )Úfunc© ú8lib/python3.7/site-packages/jedi/evaluate/syntax_tree.pyÚwrapper&   s    z&_limit_context_infers.<locals>.wrapperr*   )r)   r,   r*   )r)   r+   Ú_limit_context_infers   s    	r-   c          	   C   sN   t ƒ }xB| D ]:}y
|j}W n  tk
r:   t d|¡ Y qX ||ƒ O }qW |S )Nz%s is not actually a generator)r   Zpy__stop_iteration_returnsÚAttributeErrorr   r#   )Ú
generatorsZresultsÚ	generatorÚmethodr*   r*   r+   Ú_py__stop_iteration_returns5   s    

r2   c             C   sÈ  t  d||j¡ | j}|j}|dkr.t| |ƒS |dkrFtt | |¡ƒS |dkrXt	| |ƒS |dkr$|j
d }|j
dd … }d}|jd	kr |jd
kr d}| d¡}t| |ƒ}x@|D ]8}|dkrÜ|  |d ¡}	t|| |||	ƒ}P t| ||ƒ}q°W |r | d¡}
|
st  d| ¡ tƒ }t|
 ¡ ƒS |S |dkr@tt || |¡ƒS |dkr‚|  |j
d ¡}x"|j
d d… D ]}t||ƒ}qjW |S |dkr¬|  |j
d ¡|  |j
d ¡B S |dkrî|jdkrÞ|j}tdt|jƒ|f ƒ‚tt |d¡ƒS |dkr6t| |j
d ƒ}x(|j
dd d… D ]}|j|| d}qW |S |dkrPt| |j
d ƒS |dkrlt | |j
d ¡S |dkrºt|j
ƒr¶|j
d jdkr¶|j
d j
d }|  |¡}t|ƒS tS t | |ƒS d S )Nzeval_node %s@%s)ÚnameZnumberÚstringÚatomÚstringsÚkeywordÚlambdefÚ	expr_stmt)ZpowerZ	atom_exprr   r    Fr7   ÚawaitTz**Ú	__await__z&Tried to run py__await__ on context %s)Ztestlist_star_exprZtestlist)Znot_testZfactoréÿÿÿÿZtestÚoperator)Ú.z...zunhandled operator %s in %s ÚEllipsisZdotted_nameé   )Úname_contextZ
eval_inputÚ	annassignZ
yield_exprZ	yield_arg)!r   ÚdbgÚ	start_posr"   ÚtypeÚ	eval_atomr   r   Úfrom_contextÚeval_expr_stmtÚchildrenÚvalueÚpopÚ	eval_nodeÚ_eval_comparisonÚeval_trailerÚpy__getattribute__r#   r2   Úexecute_evaluatedr   ÚSequenceLiteralContextÚeval_factorÚparentÚAssertionErrorÚreprr   Úbuiltin_from_namer   r   Úlenr   Úeval_or_test)r%   Úelementr"   ÚtypZfirst_childrI   Z	had_awaitÚcontext_setÚtrailerÚrightZawait_context_setr=   ÚoriginZ	next_namer/   r*   r*   r+   rL   A   s„    
















rL   c             C   s   |j d d… \}}|dkrd }|dkr¨|j \}}}t|ƒ}tƒ }xFt|ƒD ]:}t|ttfƒrJt | ||¡}	|	d k	rJ| 	|¡ ||	O }qJW || 
t| j| |ƒt| |ƒ¡B S t d||¡ |dkrÌ|j| |dS |dksàtd| ƒ‚t | j| ||¡}
| |
¡S d S )	Nr@   ú)ú[zeval_trailer: %s in %sr>   )rA   Úname_or_strú(ztrailer_op is actually %s)rI   Úsetr   ÚlistÚ
isinstancer   r   r   Zpy__getitem__ÚremoveZget_itemÚeval_subscript_listr"   r	   r   rC   rO   rT   r   ZTreeArgumentsÚexecute)r%   Zbase_contextsr\   Z
trailer_opÚnodeÚ_ZfooÚresultrZ   Ztyping_module_typesr&   r*   r*   r+   rN   •   s0    
rN   c       
   	   C   st  |j dkr<t |dd¡p|}|j dkr*|}| j||jddS |j dkr”|jdkrdtt | j	|j¡ƒS |jdkrrt
S |jd	kr€t
S d
std| ƒ‚nÜt|tjƒrÂ| j	j |j¡}tt | j	|¡ƒS |j dkrt| |jd ƒ}x2|jdd… D ] }t| |ƒ}t| j	| |d|ƒ}qîW |S |j}|d dkrjt|ƒdksj|d j dkr\t|d jƒdksj|  |d ¡S y|d jd }W n ttfk
r–   Y nVX |dkrÌy|d jd }W n tk
rÊ   Y nX |j dkrìtt | j	| |¡ƒS |d }y
|j}	W n tk
r   g }	Y nX |d dkrX|dksFd|	ksFd|	krXt | j	| |¡} nt | j	| |¡} t| ƒS dS )zÁ
    Basically to process ``atom`` nodes. The parser sometimes doesn't
    generate the node (because it has just one child). In that case an atom
    might be a name or a literal as well.
    r3   r9   r8   T)ra   ÚpositionÚsearch_globalr7   )ÚFalseÚTrueÚNoneÚprintÚyieldFzCannot evaluate the keyword %sr6   r   r    Nú+rb   r@   Ztestlist_compú:é   Úcomp_forÚ{Ú}z**)rE   r   Úsearch_ancestorrO   rD   rJ   r   r   rV   r"   r   rT   re   ZLiteralZcompiled_subprocessZsafe_literal_evalÚcreate_simple_objectrF   rI   rM   rW   rL   Ú
IndexErrorr.   r   Zcomprehension_from_atomZDictLiteralContextrQ   )
r%   r5   Ústmtr4   r[   r]   Úcrv   Z
array_nodeZarray_node_cr*   r*   r+   rF   º   sl    










"
rF   c          	   C   s„   t  | j|¡l}|sf|  ¡ | jjkrfy| jj}W n tk
rD   Y n"X |jj	dkrf| 
¡ }||krfd}|rvt| ||ƒS W d Q R X tS )N)rd   rc   T)r   Zexecution_allowedr"   Úget_root_contextZbuiltins_moduleZvar_argsÚinstancer.   r3   Ústring_nameZ'get_first_non_keyword_argument_contextsÚ_eval_expr_stmtr   )r%   r|   Ú	seek_nameZallowedr   r}   r*   r*   r+   rH   
  s    rH   c          
   C   sr  t  d||¡ | ¡ }|  |¡}|r<t| |ƒ}t| j||ƒ}t| ¡ dƒ}|dkrb|j	dkrbt
 
|¡}|jdd… |_| ¡ d j}| j||jdd}	t |d	¡}
|
dk	rP|
j	d	krP|rPt |
¡rP|
 ¡ }t| |ƒ}t| ¡  |¡ƒ}xV|D ]N}|
jd
 j| ¡ i}t | |
|¡" |  |¡}t| j| |	||ƒ}	W dQ R X qøW |	}nt| j| |	||ƒ}t  d|¡ |S )a  
    The starting point of the completion. A statement always owns a call
    list, which are the calls, that a statement does. In case multiple
    names are defined in the statement, `seek_name` returns the result for
    this name.

    :param stmt: A `tree.ExprStmt`.
    zeval_expr_stmt %s (%s)N)ú=Nr=   r<   r   T)rl   rm   Úfor_stmtr    zeval_expr_stmt result %s)r   rC   Zget_rhsrL   r
   Úcheck_tuple_assignmentsr"   ÚnextZyield_operatorsrE   ÚcopyrJ   Zget_defined_namesrO   rD   r   ry   r   Zfor_stmt_defines_one_nameZget_testlistr	   rd   ÚinferÚiteraterI   r   Zpredefine_namesrM   )r%   r|   r‚   Zrhsr[   Úc_nodeZfirst_operatorr=   r3   Úleftr„   ri   ÚcnZorderedÚlazy_contextZdctÚtr*   r*   r+   r      s8    






 r   c          	   C   sÌ   t |jƒ}|  t|ƒ¡}x¢|D ]š}t|ƒ}|jdkrJd dd„ |jD ƒ¡}|dkr tdd„ |D ƒƒ}|dhkr‚|dkrž|  |¡}q¸|d	hkr¸|dkr¸|  |¡}qt| j| |||  |¡ƒ}qW t	 
d
|¡ |S )NZcomp_opú c             s   s   | ]}|j V  qd S )N)rJ   )Ú.0r}   r*   r*   r+   ú	<genexpr>W  s    zeval_or_test.<locals>.<genexpr>)ÚandÚorc             s   s   | ]}|  ¡ V  qd S )N)Ú
py__bool__)r   r‹   r*   r*   r+   r‘   [  s    Tr’   Fzeval_or_test types %s)ÚiterrI   rL   r†   rE   Újoinrc   rM   r"   r   rC   )r%   Zor_testÚiteratorÚtypesr=   r]   Z
left_boolsr*   r*   r+   rX   Q  s$    




rX   c             c   sd   x^| D ]V}|dkr&t |ƒr\| ¡ V  q|dkrV| ¡ }|dkrBdS t |j| ¡V  q|V  qW dS )z6
    Calculates `+`, `-`, `~` and `not` prefixes.
    ú-ÚnotN)r   Únegater”   r   rz   r"   )r[   r=   r%   rJ   r*   r*   r+   rR   j  s    
rR   c             C   sH   t }x>|D ]6}t|ƒr4t | |jj¡}|| ¡ O }q
|t|ƒO }q
W |S )N)r   r   r   rV   r3   r€   rP   r   )r"   rk   Z
new_resultrZ   Úclsr*   r*   r+   Ú_literals_to_types|  s    
r   c                sf   |rˆs"|pt ˆpt B }tˆ|ƒS t|ƒtˆƒ dkrDtˆ|ˆB ƒS t ‡ ‡‡‡fdd„|D ƒ¡S d S )Né   c             3   s(   | ] }ˆD ]}t ˆˆ |ˆ|ƒV  q
qd S )N)Ú_eval_comparison_part)r   r‹   r]   )r%   r"   r=   Úright_contextsr*   r+   r‘   ˜  s   z#_eval_comparison.<locals>.<genexpr>)r   r   rW   r   Z	from_sets)r"   r%   Zleft_contextsr=   r    rk   r*   )r%   r"   r=   r    r+   rM   ‹  s    
rM   c             C   s   t | tjƒo| jdkS )NÚtuple)re   r   ÚSequenceÚ
array_type)r%   r*   r*   r+   Ú	_is_tuplež  s    r¤   c             C   s   t | tjƒo| jdkS )Nrd   )re   r   r¢   r£   )r%   r*   r*   r+   Ú_is_list¢  s    r¥   c             C   s   t  | tt|ƒƒ¡S )N)r   rV   r   Ústr)r"   Úbool_r*   r*   r+   Ú_bool_to_context¦  s    r¨   c             C   sø  t |ƒ}t |ƒ}t|tƒr |}ntt|jƒƒ}|dkrrt|tjƒsJt|ƒrRt	|ƒS t|tjƒsft|ƒrnt	|ƒS n0|dkrØ|r‚|s’t|ƒr¢t|ƒr¢t	| 
||¡ƒS t|ƒr²t|ƒsÂt|ƒrÖt|ƒrÖt	t | ||f¡ƒS nÊ|dkrú|rø|røt	| 
||¡ƒS n¨|dkrt	|ƒS |tkr”t|ƒrTt|ƒrTyt	| 
||¡ƒS  tk
rP   Y nX n*|dkr~t| }|||ƒ}	t	t| |	ƒƒS t	t| dƒt| dƒƒS |dkr¢tS d	d
„ }
|dkrî||krî|
|ƒsî|
|ƒsîd}t |d||||f ¡ t	||ƒS )NÚ*rs   r™   ú%)Úisz!=z==zis notTFÚinc             S   s   t | tƒo| jjdkS )z4Checks if a Jedi object is either a float or an int.)ÚintÚfloat)re   r   r3   r€   )Úobjr*   r*   r+   ÚcheckÖ  s    
z$_eval_comparison_part.<locals>.check)rs   r™   z7TypeError: unsupported operand type(s) for +: %s and %sztype-error-operation)r   re   r   r   r¦   rJ   r   r¢   r   r   Zexecute_operationr¤   r¥   ZMergedArrayr   r   Ú	TypeErrorr¨   r   r   Úadd)r"   r%   r‹   r=   r]   Zl_is_numZr_is_numZstr_operatorZ	operationr§   r°   Úmessager*   r*   r+   rŸ   ª  sP    
 





rŸ   c             C   s$   t  |||¡}|r|S t|||dS )z›
    This is the part where statements are being stripped.

    Due to lazy evaluation, statements like a = func; b = a; b() have to be
    evaluated.
    )r‚   )r   Z"find_type_from_comment_hint_assignrH   )r"   r%   r|   r3   Zpep0484_contextsr*   r*   r+   Ú_remove_statementså  s    r´   c             C   s|  t ƒ }| ¡ j}|d k	r†| ¡  |jg ¡}xZ|D ]R}|j}t |¡|jk}|j	dkr0|j
d j	dkr0|r0|t||j
d j
d ƒO }q0W |rŽ|S g }	|jdd}
|
d kr|j}
|
j	dkrø|  ||¡}t| |||jƒ}|jdd}t|ƒg}|j|dd	S |
j	d
krtd|
j	ƒ‚|
j	}|dkr8t ||
|¡}	|	r8|	S |dkrZt ||
|¡}	|	rZ|	S |dkrÒy|j|
 |j }	W nV tk
rÎ   t||
j
d ƒ}t| ¡ ||
jj	dkd}t||ƒ}t| ||ƒ}	Y nX n¦|dkrìt| ||
|ƒ}	nŒ|dkr| |
 |¡¡}|  d¡}| !¡ S |d
kr0t" #||¡}	nH|dkrFt$||
ƒ}	n2|dkrl| | %¡  %¡ ¡}| !¡ }	ntd| ƒ‚|	S )Nr9   r    rB   T)Zimport_name_alwaysZglobal_stmt)rm   F)Zattribute_lookup)Zimport_fromZimport_namezShould not happen. type: %sr„   Z	with_stmt)r„   rv   ru   Z
async_stmt)Zcontextualized_nodeZis_asyncÚ	__enter__)ZfuncdefÚclassdefZtry_stmt)&r   r~   r!   Zget_used_namesÚgetrJ   rS   r   Zget_parent_scoperE   rI   r   Zget_definitionZcreate_contextr   Zget_filtersr†   ÚfindÚ
ValueErrorr   Zfind_type_from_comment_hint_forZ find_type_from_comment_hint_withZpredefined_namesr$   r	   r   rˆ   r
   r…   r´   rL   Zget_test_node_from_namerO   rP   r   Zinfer_importÚ_apply_decoratorsZget_previous_sibling)r"   r%   Z	tree_namer[   Zmodule_nodeÚnamesr3   r9   Zcorrect_scoper˜   ri   ÚfinderÚfiltersrZ   rŒ   Z	for_typesrŠ   Zcontext_managersZenter_methodsÚ
exceptionsr*   r*   r+   Útree_name_to_contextsô  st    















r¿   c       	      C   sì   |j dkrt| j| |d}nt | |¡}t|ƒ }}x²t| ¡ ƒD ]¢}t 	d||¡ |  
|jd ¡}|jdd… }|r”t d|¡}||_t| ||ƒ}t|ƒs®t d||¡ |S | t |g¡¡}t|ƒsØt d	|¡ |S t 	d
|¡ qBW |S )z†
    Returns the function, that should to be executed in the end.
    This is also the places where the decorators are processed.
    r¶   )Zparent_contextr!   zdecorator: %s %sr    r@   r<   r\   zdecorator not found: %s on %sz)not possible to resolve wrappers found %szdecorator end %s)rE   r   r"   r   rG   r   ÚreversedZget_decoratorsr   rC   rL   rI   r   Z
PythonNoderS   rN   rW   r#   rh   r   ZValuesArguments)	r%   ri   Zdecoratee_contextÚinitialÚvaluesZdecZ
dec_valuesZtrailer_nodesr\   r*   r*   r+   rº   ?  s0    

rº   c       	   
   C   sv   d}xl|  ¡ D ]`\}}t|j|ƒ}| |¡}x8t|d ƒD ](}yt|ƒ}W q: tk
r`   tƒ S X q:W | ¡ }qW |S )z(
    Checks if tuples are assigned.
    Nr    )	Zassignment_indexesr	   r%   r‰   Úranger†   ÚStopIterationr   rˆ   )	r"   Zcontextualized_namer[   r   Úindexri   rŒ   Ziteratedrj   r*   r*   r+   r…   d  s    
r…   c             C   sÖ   |dkrt t |ddd¡ƒS |jdkr¾|jd dks¾g }xZ|jD ]P}|dkr\|s| d¡ q@|jdkr†t|jƒdkr| |jd ¡ q@| |¡ q@W |dgd	t|ƒ  7 }t tj|f|žŽ ƒS |jd
krÌtS | |¡S )z,
    Handles slices in subscript nodes.
    rt   NZ	subscriptr   r>   Zsliceopr@   r    ru   Zsubscriptlist)	r   r   ZSlicerE   rI   ÚappendrW   r   rL   )r"   r%   rÅ   rk   Zelr*   r*   r+   rg   y  s"    

rg   )N)N)?Ú__doc__r‡   Zparso.pythonr   Zjedi._compatibilityr   r   Zjedir   r   Zjedi.evaluate.base_contextr   r   r	   r
   r   r   Zjedi.evaluater   r   r   r   r   r   r   Zjedi.evaluate.pep0484r   Zjedi.evaluate.contextr   r   r   r   r   Zjedi.evaluate.finderr   Zjedi.evaluate.helpersr   r   r   r   Zjedi.evaluate.compiled.accessr   r-   r2   Zincrease_indentrL   rN   rF   rH   r   rX   rR   r   rM   r¤   r¥   r¨   rŸ   r´   r¿   rº   r…   rg   r*   r*   r*   r+   Ú<module>   sV    S%P0;K%