ó
’›V]c           @   s|  d  Z  d d l 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 d d l 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 „  Z d d „ Z d „  Z d „  Z e ƒ  d „  ƒ Z d „  Z d „  Z e ƒ  d „  ƒ Z  d „  Z! d „  Z" d „  Z# d „  Z$ d „  Z% d „  Z& d „  Z' d „  Z( d „  Z) d S(   s  
PEP 0484 ( https://www.python.org/dev/peps/pep-0484/ ) describes type hints
through function annotations. There is a strong suggestion in this document
that only the type of type hinting defined in PEP0484 should be allowed
as annotations in future python versions.
iÿÿÿÿN(   t   ParserSyntaxErrort   parse(   t   force_unicode(   t   evaluator_method_cache(   t
   ContextSett   NO_CONTEXTS(   t   TypeVart   LazyGenericClasst   AbstractAnnotatedClass(   t   GenericClass(   t	   is_string(   t   builtin_from_name(   t   debug(   t   parser_utilsc         C   s   |  j  | ƒ } t | ƒ d k r< t j d | | f ƒ | St | ƒ d } t | ƒ r‰ t |  | j ƒ  ƒ } | d k	 r‰ |  j  | ƒ Sn  | S(   s¨   
    Evaluates an annotation node. This means that it evaluates the part of
    `int` here:

        foo: int = 3

    Also checks for forward references (strings)
    i   s8   Eval'ed typing index %s should lead to 1 object,  not %si    N(	   t	   eval_nodet   lenR   t   warningt   listR
   t   _get_forward_reference_nodet   get_safe_valuet   None(   t   contextt
   annotationt   context_sett   evaled_contextt   result(    (    s?   lib/python2.7/site-packages/jedi/evaluate/gradual/annotation.pyt   eval_annotation   s    		c            sb   t  |  | ƒ } | d  k r t S|  j | ƒ } ˆ  d  k	 r^ | j ‡  f d †  ƒ j ˆ  ƒ } n  | S(   Nc            s+   |  j  d k o* t t |  j ƒ  ƒ ƒ ˆ  k S(   Nu   tuple(   t
   array_typeR   R   t
   py__iter__(   R   (   t   index(    s?   lib/python2.7/site-packages/jedi/evaluate/gradual/annotation.pyt   <lambda>7   s   (   R   R   R   R   t   filtert   py__simple_getitem__(   R   t   stringR   t   nodeR   (    (   R   s?   lib/python2.7/site-packages/jedi/evaluate/gradual/annotation.pyt   _evaluate_annotation_string/   s    c         C   s‹   y+ |  j  j j t | ƒ d d d t ƒ} Wn# t k
 rP t j d | ƒ d  SX|  j	 j
 ƒ  } t j | | j d ƒ |  j	 | _ | Sd  S(   Nt   start_symbolt
   eval_inputt   error_recoverys   Annotation not parsed: %si    (   t	   evaluatort   grammarR   R   t   FalseR    R   R   R   t	   tree_nodet   get_root_nodeR   t   movet   end_post   parent(   R   R!   t   new_nodet   module(    (    s?   lib/python2.7/site-packages/jedi/evaluate/gradual/annotation.pyR   =   s    c         C   sÍ   y t  |  d t ƒj d } Wn# t k
 rB t j d |  ƒ g  SX| j d k re | j ƒ  j ƒ  g Sg  } y | j } Wn t	 k
 rŒ g  SXx9 | D]1 } | j d k r” | j
 | j ƒ  j ƒ  ƒ q” q” W| S(   s¦   
    Split decl_text on commas, but group generic expressions
    together.

    For example, given "foo, Bar[baz, biz]" we return
    ['foo', 'Bar[baz, biz]'].

    R&   i    s*   Comment annotation is not valid Python: %st   namet	   atom_exprt   power(   R1   R2   R3   (   R   R)   t   childrenR    R   R   t   typet   get_codet   stript   AttributeErrort   append(   t	   decl_textR"   t   paramsR4   t   child(    (    s?   lib/python2.7/site-packages/jedi/evaluate/gradual/annotation.pyt    _split_comment_param_declarationN   s     	 c      
   C   sÅ   t  |  | ƒ } |  j } | j d k rb t | d ƒ } t g  | D] } t | d | f ƒ^ q@ ƒ S| j d k rÁ t | d ƒ } t g  | D]0 } t | d t t | d ƒ g ƒ | f ƒ^ qŠ ƒ S| S(   Ni   t   tuplet   genericsi   t   dictt   str(   t   _infer_paramR'   t
   star_countR   R   R	   (   t   execution_contextt   paramt   contextsR'   t   tuple_t   ct   dct(    (    s?   lib/python2.7/site-packages/jedi/evaluate/gradual/annotation.pyt   infer_paramm   s    	&; c         C   sm  | j  } | d k rQg  | j j D] } | j d k r" | ^ q" } | j j } t j | ƒ } | d k rn t St j	 d | ƒ } | sŠ t St
 | j d ƒ ƒ } | j | ƒ }	 t | ƒ t | ƒ k rÜ t j d | | ƒ n  d d l m }
 t |  j |
 ƒ r|	 d k rt S|	 d 8}	 n  |	 t | ƒ k r1t S| |	 } t |  j j ƒ  | ƒ S|  j j ƒ  } t | | ƒ S(	   sJ   
    Infers the type of a function parameter, using type annotations.
    RE   s   ^#\s*type:\s*\(([^#]*)\)\s*->i   s&   Comments length != Params length %s %siÿÿÿÿ(   t   InstanceArgumentsi    N(   R   R   R.   R4   R5   R   t   get_following_comment_same_lineR   t   ret   matchR=   t   groupR   R   R   R   t   jedi.evaluate.context.instanceRK   t
   isinstancet   var_argsR#   t   function_contextt   get_default_param_contextR   (   RD   RE   R   R<   t
   all_paramsR"   t   commentRN   t   params_commentsR   RK   t   param_commentR   (    (    s?   lib/python2.7/site-packages/jedi/evaluate/gradual/annotation.pyRB      s<    	
c         C   se   i  } x< |  j  ƒ  D]. } | j } | d  k	 r | | | j j <q q W|  j } | ra | | d <n  | S(   Nt   return(   t
   get_paramsR   R   R1   t   value(   t   funcdefRI   t   function_paramt   param_annotationt   return_annotation(    (    s?   lib/python2.7/site-packages/jedi/evaluate/gradual/annotation.pyt   py__annotations__´   s    		c   	         s$  t  |  j ƒ } | j d d ƒ } | d k r¯ |  j } t j | ƒ } | d k rU t St j d | ƒ } | sq t St	 |  j
 j ƒ  | j d ƒ j ƒ  ƒ j ƒ  S| d k r¯ t Sn  |  j
 j ƒ  } t t | | ƒ ƒ } t | | ƒ } | sò | j ƒ  St |  | ƒ ‰  t j ‡  f d †  | Dƒ ƒ j ƒ  S(   sZ   
    Infers the type of a function's return value,
    according to type annotations.
    RY   s%   ^#\s*type:\s*\([^#]*\)\s*->\s*([^#]*)i   c         3   sB   |  ]8 } t  | t t f ƒ r- | j ˆ  ƒ n t | h ƒ Vq d  S(   N(   RQ   R   R   t   define_genericsR   (   t   .0t   ann(   t   type_var_dict(    s?   lib/python2.7/site-packages/jedi/evaluate/gradual/annotation.pys	   <genexpr>ä   s   N(   R`   R*   t   getR   R   RL   R   RM   RN   R#   RS   RT   RO   R7   t   execute_annotationR   t   find_unknown_type_varsR   t   infer_type_vars_for_executionR   t	   from_sets(	   t   function_execution_contextt   all_annotationsR   R"   RV   RN   R   t   unknown_type_varst   annotation_contexts(    (   Rd   s?   lib/python2.7/site-packages/jedi/evaluate/gradual/annotation.pyt   infer_return_typesÁ   s0    	
c         C   s	  |  j  j ƒ  } i  } |  j ƒ  \ } } xÛ | D]Ó } y | | j } Wn t k
 r[ q. n Xt | | ƒ } | r. | j | ƒ }	 | j j }
 | j	 d t
 ƒ } |
 d k r¹ | j ƒ  } n |
 d k r× | j d ƒ } n  x' |	 D] } t | t | | ƒ ƒ qÞ Wq. q. W| S(   sM  
    Some functions use type vars that are not defined by the class, but rather
    only defined in the function. See for example `iter`. In those cases we
    want to:

    1. Search for undefined type vars.
    2. Infer type vars with the execution state we have.
    3. Return the union of all type vars that have been found.
    t	   use_hintsi   i   t   _dict_values(   RS   RT   t   get_executed_params_and_issuest   string_namet   KeyErrorRg   R   t   _param_nodeRC   t   inferR)   t   merge_types_of_iteratet	   try_merget   _merge_type_var_dictst   _infer_type_vars(   RD   t   annotation_dictR   t   annotation_variable_resultst   executed_paramst   _t   executed_paramt   annotation_nodet   annotation_variablest   annotation_context_setRC   t   actual_context_setRc   (    (    s?   lib/python2.7/site-packages/jedi/evaluate/gradual/annotation.pyRh   ê   s,    
c         C   sS   xL | j  ƒ  D]> \ } } y |  | c | O<Wq t k
 rJ | |  | <q Xq Wd  S(   N(   t   itemsRs   (   t	   base_dictt   new_dictt   type_var_nameRF   (    (    s?   lib/python2.7/site-packages/jedi/evaluate/gradual/annotation.pyRx     s
    c   
      C   sm  i  } t  |  t ƒ r, i | j ƒ  |  j ƒ  6St  |  t ƒ ri|  j ƒ  } | d k rœ |  j ƒ  } | rfx1 | d D]" } t | t | | j ƒ  ƒ ƒ qp Wqfqi| d k ri|  j ƒ  } t	 | ƒ d k rfxš | D] } y | j
 } Wn t k
 rö qÍ n X| ƒ  \ } }	 x( | d D] } t | t | | ƒ ƒ qWx( | d D] } t | t | |	 ƒ ƒ q<WqÍ Wqfqin  | S(   s³  
    This function tries to find information about undefined type vars and
    returns a dict from type var name to context set.

    This is for example important to understand what `iter([1])` returns.
    According to typeshed, `iter` returns an `Iterator[_T]`:

        def iter(iterable: Iterable[_T]) -> Iterator[_T]: ...

    This functions would generate `int` for `_T` in this case, because it
    unpacks the `Iterable`.
    t   Iterablei    t   Mappingi   i   (   RQ   R   t   py__class__t
   py__name__R   t   get_genericsRx   Ry   Rv   R   t   get_mapping_item_contextsR8   (
   t   annotation_contextR   Rd   R1   t   givent   nested_annotation_contextR   t   methodt   key_contextst   value_contexts(    (    s?   lib/python2.7/site-packages/jedi/evaluate/gradual/annotation.pyRy     sH    c         C   s   t  |  | | j d | ƒ S(   Ni   (   t   _find_type_from_comment_hintR4   (   R   R"   R1   (    (    s?   lib/python2.7/site-packages/jedi/evaluate/gradual/annotation.pyt   find_type_from_comment_hint_forT  s    c         C   sO   t  | j d j ƒ d k s( t d ƒ ‚ | j d j d } t |  | | | ƒ S(   Ni   i   s1   Can only be here when children[1] is 'foo() as f'i   (   R   R4   t   AssertionErrorR“   (   R   R"   R1   t   varlist(    (    s?   lib/python2.7/site-packages/jedi/evaluate/gradual/annotation.pyt    find_type_from_comment_hint_withX  s    	c         C   s   t  |  | | j d | ƒ S(   Ni    (   R“   R4   (   R   R"   R1   (    (    s?   lib/python2.7/site-packages/jedi/evaluate/gradual/annotation.pyt"   find_type_from_comment_hint_assign_  s    c         C   sË   d  } | j d k re d } xG | j D]5 } | | k r; Pn  | j d k rP q% n  | d 7} q% Wg  Sn  t j | ƒ } | d  k r„ g  St j d | ƒ } | d  k r¦ g  St |  | j d ƒ j	 ƒ  | ƒ j
 ƒ  S(	   Nt   testlist_star_exprt   exprlistt   testlisti    t   operatori   s   ^#\s*type:\s*([^#]*)(   R™   Rš   R›   (   R   R5   R4   R   RL   RM   RN   R#   RO   R7   Rf   (   R   R"   R–   R1   R   R<   RV   RN   (    (    s?   lib/python2.7/site-packages/jedi/evaluate/gradual/annotation.pyR“   c  s$    c            s)   ‡  ‡ ‡ f d †  ‰  g  ‰ ˆ  | ƒ ˆ S(   Nc            s»   |  j  d k rl |  j d } | j  d k r· | j d d k r· x( t | j d ƒ D] } ˆ  | ƒ qR Wq· nK ˆ j |  ƒ } x9 | D]1 } t | t ƒ r‚ | ˆ k r‚ ˆ j | ƒ q‚ q‚ Wd  S(	   NR2   R3   iÿÿÿÿt   traileri    t   [i   (   R2   R3   (   R5   R4   t   _unpack_subscriptlistR   RQ   R   R9   (   R"   R   t   subscript_nodet   type_var_sett   type_var(   t
   check_nodeR   t   found(    s?   lib/python2.7/site-packages/jedi/evaluate/gradual/annotation.pyR£   }  s    "(    (   R   R"   (    (   R£   R   R¤   s?   lib/python2.7/site-packages/jedi/evaluate/gradual/annotation.pyRg   |  s    
c         c   se   |  j  d k rJ xO |  j d  d  d … D] } | j  d k r& | Vq& q& Wn |  j  d k ra |  Vn  d  S(   Nt   subscriptlisti   t	   subscript(   R5   R4   (   R¥   R¦   (    (    s?   lib/python2.7/site-packages/jedi/evaluate/gradual/annotation.pyRŸ   Ž  s    (*   t   __doc__RM   t   parsoR    R   t   jedi._compatibilityR   t   jedi.evaluate.cacheR   t   jedi.evaluate.base_contextR   R   t   jedi.evaluate.gradual.typingR   R   R   R	   t   jedi.evaluate.helpersR
   t   jedi.evaluate.compiledR   t   jediR   R   R   R   R#   R   R=   RJ   RB   R`   Rn   Rh   Rx   Ry   R”   R—   R˜   R“   Rg   RŸ   (    (    (    s?   lib/python2.7/site-packages/jedi/evaluate/gradual/annotation.pyt   <module>   s8   				3	)	(		:					